FFmpeg: libavcodec/vvc_parser.c Source File

FFmpeg

[フレーム]

libavcodec

vvc_parser.c

Go to the documentation of this file.

1 /*

2 * H.266 / VVC parser

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include "libavutil/mem.h"

24 #include "cbs.h"

25 #include "cbs_h266.h"

26 #include "parser.h"

27 #include "parser_internal.h"

29 #define START_CODE 0x000001 ///< start_code_prefix_one_3bytes

30 #define IS_IDR(nut) (nut == VVC_IDR_W_RADL || nut == VVC_IDR_N_LP)

31 #define IS_H266_SLICE(nut) (nut <= VVC_RASL_NUT || (nut >= VVC_IDR_W_RADL && nut <= VVC_GDR_NUT))

33 typedef struct PuInfo {

34 const H266RawPPS *pps;

35 const H266RawSPS *sps;

36 const H266RawPictureHeader *ph;

37 const H266RawSlice *slice;

38 int pic_type;

39 } PuInfo;

41 typedef struct AuDetector {

42 uint8_t prev_layer_id;

43 int prev_tid0_poc;

44 int prev_poc;

45 } AuDetector;

47 typedef struct VVCParserContext {

48 ParseContext pc;

49 CodedBitstreamContext *cbc;

51 CodedBitstreamFragment picture_unit;

53 AVPacket au;

54 AVPacket last_au;

56 AuDetector au_detector;

58 int parsed_extradata;

59 } VVCParserContext;

61 static const enum AVPixelFormat pix_fmts_8bit[] = {

62 AV_PIX_FMT_GRAY8, AV_PIX_FMT_YUV420P,

63 AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P

64 };

66 static const enum AVPixelFormat pix_fmts_10bit[] = {

67 AV_PIX_FMT_GRAY10, AV_PIX_FMT_YUV420P10,

68 AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10

69 };

71 static int get_format(const H266RawSPS *sps)

72 {

73 switch (sps->sps_bitdepth_minus8) {

74 case 0:

75 return pix_fmts_8bit[sps->sps_chroma_format_idc];

76 case 2:

77 return pix_fmts_10bit[sps->sps_chroma_format_idc];

78 }

79 return AV_PIX_FMT_NONE;

80 }

82 /**

83 * Find the end of the current frame in the bitstream.

84 * @return the position of the first byte of the next frame, or END_NOT_FOUND

85 */

86 static int find_frame_end(AVCodecParserContext *s, const uint8_t *buf,

87 int buf_size)

88 {

89 VVCParserContext *ctx = s->priv_data;

90 ParseContext *pc = &ctx->pc;

91 int i;

93 for (i = 0; i < buf_size; i++) {

94 int nut, code_len;

96 pc->state64 = (pc->state64 << 8) | buf[i];

98 if (((pc->state64 >> 3 * 8) & 0xFFFFFF) != START_CODE)

99 continue;

100

101 code_len = ((pc->state64 >> 3 * 8) & 0xFFFFFFFF) == 0x01 ? 4 : 3;

102

103 nut = (pc->state64 >> (8 + 3)) & 0x1F;

104 // 7.4.2.4.3 and 7.4.2.4.4

105 if ((nut >= VVC_OPI_NUT && nut <= VVC_PREFIX_APS_NUT &&

106 nut != VVC_PH_NUT) || nut == VVC_AUD_NUT

107 || (nut == VVC_PREFIX_SEI_NUT && !pc->frame_start_found)

108 || nut == VVC_RSV_NVCL_26 || nut == VVC_UNSPEC_28

109 || nut == VVC_UNSPEC_29) {

110 if (pc->frame_start_found) {

111 pc->frame_start_found = 0;

112 return i - (code_len + 2);

113 }

114 } else if (nut == VVC_PH_NUT || IS_H266_SLICE(nut)) {

115 int sh_picture_header_in_slice_header_flag = buf[i] >> 7;

116

117 if (nut == VVC_PH_NUT || sh_picture_header_in_slice_header_flag) {

118 if (!pc->frame_start_found) {

119 pc->frame_start_found = 1;

120 } else { // First slice of next frame found

121 pc->frame_start_found = 0;

122 return i - (code_len + 2);

123 }

124 }

125 }

126 }

127 return END_NOT_FOUND;

128 }

129

130 static int get_pict_type(const CodedBitstreamFragment *pu)

131 {

132 int has_p = 0;

133 for (int i = 0; i < pu->nb_units; i++) {

134 CodedBitstreamUnit *unit = &pu->units[i];

135 if (IS_H266_SLICE(unit->type)) {

136 const H266RawSlice *slice = unit->content;

137 uint8_t type = slice->header.sh_slice_type;

138 if (type == VVC_SLICE_TYPE_B) {

139 return AV_PICTURE_TYPE_B;

140 }

141 if (type == VVC_SLICE_TYPE_P) {

142 has_p = 1;

143 }

144 }

145 }

146 return has_p ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;

147 }

148

149 static void set_parser_ctx(AVCodecParserContext *s, AVCodecContext *avctx,

150 const PuInfo *pu)

151 {

152 static const uint8_t h266_sub_width_c[] = {

153 1, 2, 2, 1

154 };

155 static const uint8_t h266_sub_height_c[] = {

156 1, 2, 1, 1

157 };

158 const H266RawSPS *sps = pu->sps;

159 const H266RawPPS *pps = pu->pps;

160 const H266RawNALUnitHeader *nal = &pu->slice->header.nal_unit_header;

161

162 s->pict_type = pu->pic_type;

163 s->format = get_format(sps);

164 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

165

166 s->key_frame = nal->nal_unit_type == VVC_IDR_W_RADL ||

167 nal->nal_unit_type == VVC_IDR_N_LP ||

168 nal->nal_unit_type == VVC_CRA_NUT ||

169 nal->nal_unit_type == VVC_GDR_NUT;

170

171 s->coded_width = pps->pps_pic_width_in_luma_samples;

172 s->coded_height = pps->pps_pic_height_in_luma_samples;

173 s->width = pps->pps_pic_width_in_luma_samples -

174 (pps->pps_conf_win_left_offset + pps->pps_conf_win_right_offset) *

175 h266_sub_width_c[sps->sps_chroma_format_idc];

176 s->height = pps->pps_pic_height_in_luma_samples -

177 (pps->pps_conf_win_top_offset + pps->pps_conf_win_bottom_offset) *

178 h266_sub_height_c[sps->sps_chroma_format_idc];

179

180 avctx->profile = sps->profile_tier_level.general_profile_idc;

181 avctx->level = sps->profile_tier_level.general_level_idc;

182

183 avctx->colorspace = (enum AVColorSpace) sps->vui.vui_matrix_coeffs;

184 avctx->color_primaries = (enum AVColorPrimaries) sps->vui.vui_colour_primaries;

185 avctx->color_trc = (enum AVColorTransferCharacteristic) sps->vui.vui_transfer_characteristics;

186 avctx->color_range =

187 sps->vui.vui_full_range_flag ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

188

189 if (sps->sps_ptl_dpb_hrd_params_present_flag &&

190 sps->sps_timing_hrd_params_present_flag) {

191 uint32_t num = sps->sps_general_timing_hrd_parameters.num_units_in_tick;

192 uint32_t den = sps->sps_general_timing_hrd_parameters.time_scale;

193

194 if (num != 0 && den != 0)

195 av_reduce(&avctx->framerate.den, &avctx->framerate.num,

196 num, den, 1 << 30);

197 }

198 }

199

200 //8.3.1 Decoding process for picture order count.

201 //VTM did not follow the spec, and it's much simpler than spec.

202 //We follow the VTM.

203 static void get_slice_poc(VVCParserContext *s, int *poc,

204 const H266RawSPS *sps,

205 const H266RawPictureHeader *ph,

206 const H266RawSliceHeader *slice, void *log_ctx)

207 {

208 int poc_msb, max_poc_lsb, poc_lsb;

209 AuDetector *d = &s->au_detector;

210 max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);

211 poc_lsb = ph->ph_pic_order_cnt_lsb;

212 if (IS_IDR(slice->nal_unit_header.nal_unit_type)) {

213 if (ph->ph_poc_msb_cycle_present_flag)

214 poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;

215 else

216 poc_msb = 0;

217 } else {

218 int prev_poc = d->prev_tid0_poc;

219 int prev_poc_lsb = prev_poc & (max_poc_lsb - 1);

220 int prev_poc_msb = prev_poc - prev_poc_lsb;

221 if (ph->ph_poc_msb_cycle_present_flag) {

222 poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;

223 } else {

224 if ((poc_lsb < prev_poc_lsb) && ((prev_poc_lsb - poc_lsb) >=

225 (max_poc_lsb / 2)))

226 poc_msb = prev_poc_msb + (unsigned)max_poc_lsb;

227 else if ((poc_lsb > prev_poc_lsb) && ((poc_lsb - prev_poc_lsb) >

228 (max_poc_lsb / 2)))

229 poc_msb = prev_poc_msb - (unsigned)max_poc_lsb;

230 else

231 poc_msb = prev_poc_msb;

232 }

233 }

234

235 *poc = poc_msb + poc_lsb;

236 }

237

238 static void au_detector_init(AuDetector *d)

239 {

240 d->prev_layer_id = UINT8_MAX;

241 d->prev_poc = INT_MAX;

242 d->prev_tid0_poc = INT_MAX;

243 }

244

245 static int is_au_start(VVCParserContext *s, const PuInfo *pu, void *log_ctx)

246 {

247 //7.4.2.4.3

248 AuDetector *d = &s->au_detector;

249 const H266RawSPS *sps = pu->sps;

250 const H266RawNALUnitHeader *nal = &pu->slice->header.nal_unit_header;

251 const H266RawPictureHeader *ph = pu->ph;

252 const H266RawSlice *slice = pu->slice;

253 int ret, poc, nut;

254

255 get_slice_poc(s, &poc, sps, ph, &slice->header, log_ctx);

256

257 ret = (nal->nuh_layer_id <= d->prev_layer_id) || (poc != d->prev_poc);

258

259 nut = nal->nal_unit_type;

260 d->prev_layer_id = nal->nuh_layer_id;

261 d->prev_poc = poc;

262 if (nal->nuh_temporal_id_plus1 == 1 &&

263 !ph->ph_non_ref_pic_flag && nut != VVC_RADL_NUT

264 && nut != VVC_RASL_NUT) {

265 d->prev_tid0_poc = poc;

266 }

267 return ret;

268 }

269

270 static int get_pu_info(PuInfo *info, const CodedBitstreamH266Context *h266,

271 const CodedBitstreamFragment *pu, void *logctx)

272 {

273 const H266RawNALUnitHeader *nal;

274 int ret;

275

276 memset(info, 0, sizeof(*info));

277 for (int i = 0; i < pu->nb_units; i++) {

278 nal = pu->units[i].content;

279 if (!nal)

280 continue;

281 if ( nal->nal_unit_type == VVC_PH_NUT ) {

282 const H266RawPH *ph = pu->units[i].content;

283 info->ph = &ph->ph_picture_header;

284 } else if (IS_H266_SLICE(nal->nal_unit_type)) {

285 info->slice = pu->units[i].content;

286 if (info->slice->header.sh_picture_header_in_slice_header_flag)

287 info->ph = &info->slice->header.sh_picture_header;

288 if (!info->ph) {

289 av_log(logctx, AV_LOG_ERROR,

290 "can't find picture header in picture unit.\n");

291 ret = AVERROR_INVALIDDATA;

292 goto error;

293 }

294 break;

295 }

296 }

297 if (!info->slice) {

298 av_log(logctx, AV_LOG_ERROR, "can't find slice in picture unit.\n");

299 ret = AVERROR_INVALIDDATA;

300 goto error;

301 }

302 info->pps = h266->pps[info->ph->ph_pic_parameter_set_id];

303 if (!info->pps) {

304 av_log(logctx, AV_LOG_ERROR, "PPS id %d is not available.\n",

305 info->ph->ph_pic_parameter_set_id);

306 ret = AVERROR_INVALIDDATA;

307 goto error;

308 }

309 info->sps = h266->sps[info->pps->pps_seq_parameter_set_id];

310 if (!info->sps) {

311 av_log(logctx, AV_LOG_ERROR, "SPS id %d is not available.\n",

312 info->pps->pps_seq_parameter_set_id);

313 ret = AVERROR_INVALIDDATA;

314 goto error;

315 }

316 info->pic_type = get_pict_type(pu);

317 return 0;

318 error:

319 memset(info, 0, sizeof(*info));

320 return ret;

321 }

322

323 static int append_au(AVPacket *pkt, const uint8_t *buf, int buf_size)

324 {

325 int offset = pkt->size;

326 int ret;

327 if ((ret = av_grow_packet(pkt, buf_size)) < 0)

328 goto end;

329 memcpy(pkt->data + offset, buf, buf_size);

330 end:

331 return ret;

332 }

333

334 /**

335 * Parse NAL units of found picture and decode some basic information.

336 *

337 * @param s parser context.

338 * @param avctx codec context.

339 * @param buf buffer with field/frame data.

340 * @param buf_size size of the buffer.

341 * @return < 0 for error, == 0 for a complete au, > 0 is not a completed au.

342 */

343 static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,

344 int buf_size, AVCodecContext *avctx)

345 {

346 VVCParserContext *ctx = s->priv_data;

347 const CodedBitstreamH266Context *h266 = ctx->cbc->priv_data;

348

349 CodedBitstreamFragment *pu = &ctx->picture_unit;

350 int ret;

351 PuInfo info;

352

353 if (!buf_size) {

354 if (ctx->au.size) {

355 av_packet_move_ref(&ctx->last_au, &ctx->au);

356 return 0;

357 }

358 return 1;

359 }

360

361 if ((ret = ff_cbs_read(ctx->cbc, pu, NULL, buf, buf_size)) < 0) {

362 av_log(avctx, AV_LOG_ERROR, "Failed to parse picture unit.\n");

363 goto end;

364 }

365 if ((ret = get_pu_info(&info, h266, pu, avctx)) < 0)

366 goto end;

367 if (append_au(&ctx->au, buf, buf_size) < 0) {

368 ret = AVERROR(ENOMEM);

369 goto end;

370 }

371 if (is_au_start(ctx, &info, avctx)) {

372 set_parser_ctx(s, avctx, &info);

373 av_packet_move_ref(&ctx->last_au, &ctx->au);

374 } else {

375 ret = 1; //not a completed au

376 }

377 end:

378 ff_cbs_fragment_reset(pu);

379 return ret;

380 }

381

382 /**

383 * Combine PU to AU

384 *

385 * @param s parser context.

386 * @param avctx codec context.

387 * @param buf buffer to a PU.

388 * @param buf_size size of the buffer.

389 * @return < 0 for error, == 0 a complete au, > 0 not a completed au.

390 */

391 static int combine_au(AVCodecParserContext *s, AVCodecContext *avctx,

392 const uint8_t **buf, int *buf_size)

393 {

394 VVCParserContext *ctx = s->priv_data;

395 int ret;

396

397 ctx->cbc->log_ctx = avctx;

398

399 av_packet_unref(&ctx->last_au);

400 ret = parse_nal_units(s, *buf, *buf_size, avctx);

401 if (ret == 0) {

402 if (ctx->last_au.size) {

403 *buf = ctx->last_au.data;

404 *buf_size = ctx->last_au.size;

405 } else {

406 ret = 1; //no output

407 }

408 }

409 ctx->cbc->log_ctx = NULL;

410 return ret;

411 }

412

413 static int vvc_parser_parse(AVCodecParserContext *s, AVCodecContext *avctx,

414 const uint8_t **poutbuf, int *poutbuf_size,

415 const uint8_t *buf, int buf_size)

416 {

417 int next, ret;

418 VVCParserContext *ctx = s->priv_data;

419 ParseContext *pc = &ctx->pc;

420 CodedBitstreamFragment *pu = &ctx->picture_unit;

421

422 int is_dummy_buf = !buf_size;

423 int flush = !buf_size;

424 const uint8_t *dummy_buf = buf;

425

426 *poutbuf = NULL;

427 *poutbuf_size = 0;

428

429 if (avctx->extradata_size && !ctx->parsed_extradata) {

430 ctx->parsed_extradata = 1;

431

432 ret = ff_cbs_read_extradata_from_codec(ctx->cbc, pu, avctx);

433 if (ret < 0)

434 av_log(avctx, AV_LOG_WARNING, "Failed to parse extradata.\n");

435

436 ff_cbs_fragment_reset(pu);

437 }

438

439 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

440 next = buf_size;

441 } else {

442 next = find_frame_end(s, buf, buf_size);

443 if (ff_combine_frame(pc, next, &buf, &buf_size) < 0)

444 return buf_size;

445 }

446

447 is_dummy_buf &= (dummy_buf == buf);

448

449 if (!is_dummy_buf) {

450 ret = combine_au(s, avctx, &buf, &buf_size);

451 if (ret > 0 && flush) {

452 buf_size = 0;

453 ret = combine_au(s, avctx, &buf, &buf_size);

454 }

455 if (ret != 0)

456 return next;

457 }

458

459 *poutbuf = buf;

460 *poutbuf_size = buf_size;

461

462 return next;

463 }

464

465 static const CodedBitstreamUnitType decompose_unit_types[] = {

466 VVC_TRAIL_NUT,

467 VVC_STSA_NUT,

468 VVC_RADL_NUT,

469 VVC_RASL_NUT,

470 VVC_IDR_W_RADL,

471 VVC_IDR_N_LP,

472 VVC_CRA_NUT,

473 VVC_GDR_NUT,

474 VVC_VPS_NUT,

475 VVC_SPS_NUT,

476 VVC_PPS_NUT,

477 VVC_PH_NUT,

478 VVC_AUD_NUT,

479 };

480

481 static av_cold int vvc_parser_init(AVCodecParserContext *s)

482 {

483 VVCParserContext *ctx = s->priv_data;

484 int ret;

485

486 ret = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_VVC, NULL);

487 if (ret < 0)

488 return ret;

489 au_detector_init(&ctx->au_detector);

490

491 ctx->cbc->decompose_unit_types = decompose_unit_types;

492 ctx->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);

493

494 return ret;

495 }

496

497 static av_cold void vvc_parser_close(AVCodecParserContext *s)

498 {

499 VVCParserContext *ctx = s->priv_data;

500

501 av_packet_unref(&ctx->au);

502 av_packet_unref(&ctx->last_au);

503 ff_cbs_fragment_free(&ctx->picture_unit);

504

505 ff_cbs_close(&ctx->cbc);

506 av_freep(&ctx->pc.buffer);

507 }

508

509 const FFCodecParser ff_vvc_parser = {

510 PARSER_CODEC_LIST(AV_CODEC_ID_VVC),

511 .priv_data_size = sizeof(VVCParserContext),

512 .init = vvc_parser_init,

513 .close = vvc_parser_close,

514 .parse = vvc_parser_parse,

515 };

VVC_RADL_NUT

@ VVC_RADL_NUT

Definition: vvc.h:31

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

au_detector_init

static void au_detector_init(AuDetector *d)

Definition: vvc_parser.c:238

VVC_RASL_NUT

@ VVC_RASL_NUT

Definition: vvc.h:32

VVC_GDR_NUT

@ VVC_GDR_NUT

Definition: vvc.h:39

VVC_STSA_NUT

@ VVC_STSA_NUT

Definition: vvc.h:30

START_CODE

#define START_CODE

start_code_prefix_one_3bytes

Definition: vvc_parser.c:29

cbs.h

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:432

PuInfo::ph

const H266RawPictureHeader * ph

Definition: vvc_parser.c:36

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

cbs_h266.h

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:659

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:666

CodedBitstreamUnit::content

void * content

Pointer to the decomposed form of this unit.

Definition: cbs.h:114

av_grow_packet

int av_grow_packet(AVPacket *pkt, int grow_by)

Increase packet size, correctly zeroing padding.

Definition: packet.c:121

VVCParserContext::pc

ParseContext pc

Definition: vvc_parser.c:48

static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)

Definition: cbs_h266_syntax_template.c:3037

parser_internal.h

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:652

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:777

AVPacket::data

uint8_t * data

Definition: packet.h:588

CodedBitstreamContext

Context structure for coded bitstream operations.

Definition: cbs.h:226

decompose_unit_types

static const CodedBitstreamUnitType decompose_unit_types[]

Definition: vvc_parser.c:465

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:539

IS_IDR

#define IS_IDR(nut)

Definition: vvc_parser.c:30

CodedBitstreamUnit::type

CodedBitstreamUnitType type

Codec-specific type of this unit.

Definition: cbs.h:81

H266RawNALUnitHeader::nuh_layer_id

uint8_t nuh_layer_id

Definition: cbs_h266.h:30

AVColorPrimaries

Chromaticity coordinates of the source primaries.

Definition: pixfmt.h:636

H266RawNALUnitHeader::nal_unit_type

uint8_t nal_unit_type

Definition: cbs_h266.h:31

PuInfo::sps

const H266RawSPS * sps

Definition: vvc_parser.c:35

VVC_AUD_NUT

@ VVC_AUD_NUT

Definition: vvc.h:49

vvc_parser_parse

static int vvc_parser_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)

Definition: vvc_parser.c:413

CodedBitstreamUnit

Coded bitstream unit structure.

Definition: cbs.h:77

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:551

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

CodedBitstreamH266Context::pps

H266RawPPS * pps[VVC_MAX_PPS_COUNT]

RefStruct references.

Definition: cbs_h266.h:871

ParseContext

Definition: parser.h:28

VVC_RSV_NVCL_26

@ VVC_RSV_NVCL_26

Definition: vvc.h:55

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

VVCParserContext::au

AVPacket au

Definition: vvc_parser.c:53

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

AVRational::num

int num

Numerator.

Definition: rational.h:59

VVC_IDR_W_RADL

@ VVC_IDR_W_RADL

Definition: vvc.h:36

VVCParserContext::au_detector

AuDetector au_detector

Definition: vvc_parser.c:56

VVCParserContext::picture_unit

CodedBitstreamFragment picture_unit

Definition: vvc_parser.c:51

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:542

CodedBitstreamFragment::units

CodedBitstreamUnit * units

Pointer to an array of units of length nb_units_allocated.

Definition: cbs.h:175

AV_PICTURE_STRUCTURE_FRAME

@ AV_PICTURE_STRUCTURE_FRAME

coded as frame

Definition: avcodec.h:2572

AVCodecContext::color_primaries

enum AVColorPrimaries color_primaries

Chromaticity coordinates of the source primaries.

Definition: avcodec.h:645

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

AuDetector::prev_tid0_poc

int prev_tid0_poc

Definition: vvc_parser.c:43

CodedBitstreamFragment

Coded bitstream fragment structure, combining one or more units.

Definition: cbs.h:129

PuInfo

Definition: vvc_parser.c:33

#define s(width, name)

Definition: cbs_vp9.c:198

info

MIPS optimizations info

Definition: mips.txt:2

CodedBitstreamUnitType

uint32_t CodedBitstreamUnitType

The codec-specific type of a bitstream unit.

Definition: cbs.h:54

H266RawNALUnitHeader::nuh_temporal_id_plus1

uint8_t nuh_temporal_id_plus1

Definition: cbs_h266.h:32

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

VVC_UNSPEC_29

@ VVC_UNSPEC_29

Definition: vvc.h:58

AV_PIX_FMT_GRAY10

#define AV_PIX_FMT_GRAY10

Definition: pixfmt.h:519

if(ret)

Definition: filter_design.txt:179

H266RawSPS

Definition: cbs_h266.h:308

VVC_SLICE_TYPE_P

@ VVC_SLICE_TYPE_P

Definition: vvc.h:65

is_au_start

static int is_au_start(VVCParserContext *s, const PuInfo *pu, void *log_ctx)

Definition: vvc_parser.c:245

H266RawPPS

Definition: cbs_h266.h:496

NULL

#define NULL

Definition: coverity.c:32

H266RawPictureHeader

Definition: cbs_h266.h:676

PuInfo::pic_type

int pic_type

Definition: vvc_parser.c:38

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:669

VVC_PREFIX_SEI_NUT

@ VVC_PREFIX_SEI_NUT

Definition: vvc.h:52

VVC_SLICE_TYPE_B

@ VVC_SLICE_TYPE_B

Definition: vvc.h:64

VVCParserContext

Definition: vvc_parser.c:47

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

ParseContext::frame_start_found

int frame_start_found

Definition: parser.h:34

flush

void(* flush)(AVBSFContext *ctx)

Definition: dts2pts.c:552

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:540

VVC_PH_NUT

@ VVC_PH_NUT

Definition: vvc.h:48

AuDetector::prev_layer_id

uint8_t prev_layer_id

Definition: vvc_parser.c:42

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

av_packet_move_ref

void av_packet_move_ref(AVPacket *dst, AVPacket *src)

Move every field in src to dst and reset src.

Definition: packet.c:489

parse

static int parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)

Definition: apv_parser.c:46

AVCodecContext::level

int level

Encoding level descriptor.

Definition: avcodec.h:1628

get_slice_poc

static void get_slice_poc(VVCParserContext *s, int *poc, const H266RawSPS *sps, const H266RawPictureHeader *ph, const H266RawSliceHeader *slice, void *log_ctx)

Definition: vvc_parser.c:203

parse_nal_units

static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf, int buf_size, AVCodecContext *avctx)

Parse NAL units of found picture and decode some basic information.

Definition: vvc_parser.c:343

pix_fmts_10bit

static enum AVPixelFormat pix_fmts_10bit[]

Definition: vvc_parser.c:66

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

AVPacket::size

int size

Definition: packet.h:589

VVC_VPS_NUT

@ VVC_VPS_NUT

Definition: vvc.h:43

VVCParserContext::parsed_extradata

int parsed_extradata

Definition: vvc_parser.c:58

pix_fmts_8bit

static enum AVPixelFormat pix_fmts_8bit[]

Definition: vvc_parser.c:61

VVCParserContext::last_au

AVPacket last_au

Definition: vvc_parser.c:54

AuDetector::prev_poc

int prev_poc

Definition: vvc_parser.c:44

combine_au

static int combine_au(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **buf, int *buf_size)

Combine PU to AU.

Definition: vvc_parser.c:391

CodedBitstreamH266Context

Definition: cbs_h266.h:863

AV_CODEC_ID_VVC

@ AV_CODEC_ID_VVC

Definition: codec_id.h:252

VVC_TRAIL_NUT

@ VVC_TRAIL_NUT

Definition: vvc.h:29

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

VVC_SPS_NUT

@ VVC_SPS_NUT

Definition: vvc.h:44

ff_combine_frame

int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)

Combine the (truncated) bitstream to a complete frame.

Definition: parser.c:211

FFCodecParser

Definition: parser_internal.h:29

VVCParserContext::cbc

CodedBitstreamContext * cbc

Definition: vvc_parser.c:49

H266RawSliceHeader

Definition: cbs_h266.h:771

PuInfo::slice

const H266RawSlice * slice

Definition: vvc_parser.c:37

ff_vvc_parser

const FFCodecParser ff_vvc_parser

Definition: vvc_parser.c:509

PARSER_FLAG_COMPLETE_FRAMES

#define PARSER_FLAG_COMPLETE_FRAMES

Definition: avcodec.h:2609

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

VVC_UNSPEC_28

@ VVC_UNSPEC_28

Definition: vvc.h:57

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:700

CodedBitstreamH266Context::sps

H266RawSPS * sps[VVC_MAX_SPS_COUNT]

RefStruct references.

Definition: cbs_h266.h:870

VVC_IDR_N_LP

@ VVC_IDR_N_LP

Definition: vvc.h:37

parser.h

PuInfo::pps

const H266RawPPS * pps

Definition: vvc_parser.c:34

PARSER_CODEC_LIST

#define PARSER_CODEC_LIST(...)

Definition: parser_internal.h:76

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:760

IS_H266_SLICE

#define IS_H266_SLICE(nut)

Definition: vvc_parser.c:31

vvc_parser_init

static av_cold int vvc_parser_init(AVCodecParserContext *s)

Definition: vvc_parser.c:481

get_pict_type

static int get_pict_type(const CodedBitstreamFragment *pu)

Definition: vvc_parser.c:130

AVCodecParserContext

Definition: avcodec.h:2575

append_au

static int append_au(AVPacket *pkt, const uint8_t *buf, int buf_size)

Definition: vvc_parser.c:323

ret

Definition: filter_design.txt:187

H266RawSliceHeader::sh_slice_type

uint8_t sh_slice_type

Definition: cbs_h266.h:780

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

H266RawSlice::header

H266RawSliceHeader header

Definition: cbs_h266.h:844

VVC_PPS_NUT

@ VVC_PPS_NUT

Definition: vvc.h:45

H266RawSliceHeader::nal_unit_header

H266RawNALUnitHeader nal_unit_header

Definition: cbs_h266.h:772

AVCodecContext

main external API structure.

Definition: avcodec.h:431

VVC_PREFIX_APS_NUT

@ VVC_PREFIX_APS_NUT

Definition: vvc.h:46

H266RawPH

Definition: cbs_h266.h:766

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:280

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1618

vvc_parser_close

static av_cold void vvc_parser_close(AVCodecParserContext *s)

Definition: vvc_parser.c:497

set_parser_ctx

static void set_parser_ctx(AVCodecParserContext *s, AVCodecContext *avctx, const PuInfo *pu)

Definition: vvc_parser.c:149

ParseContext::state64

uint64_t state64

contains the last 8 bytes in MSB order

Definition: parser.h:37

pps

uint64_t pps

Definition: dovi_rpuenc.c:36

VVC_CRA_NUT

@ VVC_CRA_NUT

Definition: vvc.h:38

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:78

VVC_OPI_NUT

@ VVC_OPI_NUT

Definition: vvc.h:41

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:279

AV_PIX_FMT_YUV422P

@ AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:77

mem.h

END_NOT_FOUND

#define END_NOT_FOUND

Definition: parser.h:40

AVPacket

This structure stores compressed data.

Definition: packet.h:565

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AuDetector

Definition: vvc_parser.c:41

get_format

static int get_format(const H266RawSPS *sps)

Definition: vvc_parser.c:71

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

H266RawNALUnitHeader

Definition: cbs_h266.h:29

find_frame_end

static int find_frame_end(AVCodecParserContext *s, const uint8_t *buf, int buf_size)

Find the end of the current frame in the bitstream.

Definition: vvc_parser.c:86

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1292

get_pu_info

static int get_pu_info(PuInfo *info, const CodedBitstreamH266Context *h266, const CodedBitstreamFragment *pu, void *logctx)

Definition: vvc_parser.c:270

CodedBitstreamFragment::nb_units

int nb_units

Number of units in this fragment.

Definition: cbs.h:160

H266RawSlice

Definition: cbs_h266.h:843

Generated on Tue Nov 18 2025 19:22:53 for FFmpeg by doxygen 1.8.17