FFmpeg: libavcodec/h264_parser.c Source File

FFmpeg

[フレーム]

libavcodec

h264_parser.c

Go to the documentation of this file.

1 /*

2 * H.26L/H.264/AVC/JVT/14496-10/... parser

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * H.264 / AVC / MPEG-4 part10 parser.

25 * @author Michael Niedermayer <michaelni@gmx.at>

26 */

28 #define UNCHECKED_BITSTREAM_READER 1

30 #include <stdint.h>

32 #include "libavutil/attributes.h"

33 #include "libavutil/avutil.h"

34 #include "libavutil/error.h"

35 #include "libavutil/log.h"

36 #include "libavutil/mem.h"

37 #include "libavutil/pixfmt.h"

39 #include "avcodec.h"

40 #include "get_bits.h"

41 #include "golomb.h"

42 #include "h264.h"

43 #include "h264dsp.h"

44 #include "h264_parse.h"

45 #include "h264_sei.h"

46 #include "h264_ps.h"

47 #include "h2645_parse.h"

48 #include "h264data.h"

49 #include "mpegutils.h"

50 #include "parser.h"

51 #include "libavutil/refstruct.h"

52 #include "parser_internal.h"

53 #include "startcode.h"

55 typedef struct H264ParseContext {

56 ParseContext pc;

57 H264ParamSets ps;

58 H264DSPContext h264dsp;

59 H264POCContext poc;

60 H264SEIContext sei;

61 int is_avc;

62 int nal_length_size;

63 int got_first;

64 int picture_structure;

65 uint8_t parse_history[6];

66 int parse_history_count;

67 int parse_last_mb;

68 int64_t reference_dts;

69 int last_frame_num, last_picture_structure;

70 } H264ParseContext;

72 static int find_start_code(const uint8_t *buf, int buf_size,

73 int buf_index, int next_avc)

74 {

75 uint32_t state = -1;

77 buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1;

79 return FFMIN(buf_index, buf_size);

80 }

82 static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,

83 int buf_size, void *logctx)

84 {

85 int i, j;

86 uint32_t state;

87 ParseContext *pc = &p->pc;

89 int next_avc = p->is_avc ? 0 : buf_size;

90 // mb_addr= pc->mb_addr - 1;

91 state = pc->state;

92 if (state > 13)

93 state = 7;

95 if (p->is_avc && !p->nal_length_size)

96 av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");

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

99 if (i >= next_avc) {

100 int64_t nalsize = 0;

101 i = next_avc;

102 for (j = 0; j < p->nal_length_size; j++)

103 nalsize = (nalsize << 8) | buf[i++];

104 if (!nalsize || nalsize > buf_size - i) {

105 av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %"PRId64" "

106 "remaining %d\n", nalsize, buf_size - i);

107 return buf_size;

108 }

109 next_avc = i + nalsize;

110 state = 5;

111 }

112

113 if (state == 7) {

114 i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i);

115 if (i < next_avc)

116 state = 2;

117 } else if (state <= 2) {

118 if (buf[i] == 1)

119 state ^= 5; // 2->7, 1->4, 0->5

120 else if (buf[i])

121 state = 7;

122 else

123 state >>= 1; // 2->1, 1->0, 0->0

124 } else if (state <= 5) {

125 int nalu_type = buf[i] & 0x1F;

126 if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||

127 nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {

128 if (pc->frame_start_found) {

129 i++;

130 goto found;

131 }

132 } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||

133 nalu_type == H264_NAL_IDR_SLICE) {

134 state += 8;

135 continue;

136 }

137 state = 7;

138 } else {

139 unsigned int mb, last_mb = p->parse_last_mb;

140 GetBitContext gb;

141 p->parse_history[p->parse_history_count++] = buf[i];

142

143 init_get_bits(&gb, p->parse_history, 8*p->parse_history_count);

144 mb= get_ue_golomb_long(&gb);

145 if (get_bits_left(&gb) > 0 || p->parse_history_count > 5) {

146 p->parse_last_mb = mb;

147 if (pc->frame_start_found) {

148 if (mb <= last_mb) {

149 i -= p->parse_history_count - 1;

150 p->parse_history_count = 0;

151 goto found;

152 }

153 } else

154 pc->frame_start_found = 1;

155 p->parse_history_count = 0;

156 state = 7;

157 }

158 }

159 }

160 pc->state = state;

161 if (p->is_avc)

162 return next_avc;

163 return END_NOT_FOUND;

164

165 found:

166 pc->state = 7;

167 pc->frame_start_found = 0;

168 if (p->is_avc)

169 return next_avc;

170 return i - (state & 5);

171 }

172

173 static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,

174 void *logctx)

175 {

176 H264PredWeightTable pwt;

177 int slice_type_nos = s->pict_type & 3;

178 H264ParseContext *p = s->priv_data;

179 int list_count, ref_count[2];

180

181

182 if (p->ps.pps->redundant_pic_cnt_present)

183 get_ue_golomb(gb); // redundant_pic_count

184

185 if (slice_type_nos == AV_PICTURE_TYPE_B)

186 get_bits1(gb); // direct_spatial_mv_pred

187

188 if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,

189 slice_type_nos, p->picture_structure, logctx) < 0)

190 return AVERROR_INVALIDDATA;

191

192 if (slice_type_nos != AV_PICTURE_TYPE_I) {

193 int list;

194 for (list = 0; list < list_count; list++) {

195 if (get_bits1(gb)) {

196 int index;

197 for (index = 0; ; index++) {

198 unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);

199

200 if (reordering_of_pic_nums_idc < 3)

201 get_ue_golomb_long(gb);

202 else if (reordering_of_pic_nums_idc > 3) {

203 av_log(logctx, AV_LOG_ERROR,

204 "illegal reordering_of_pic_nums_idc %d\n",

205 reordering_of_pic_nums_idc);

206 return AVERROR_INVALIDDATA;

207 } else

208 break;

209

210 if (index >= ref_count[list]) {

211 av_log(logctx, AV_LOG_ERROR,

212 "reference count %d overflow\n", index);

213 return AVERROR_INVALIDDATA;

214 }

215 }

216 }

217 }

218 }

219

220 if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||

221 (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))

222 ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,

223 &pwt, p->picture_structure, logctx);

224

225 if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag

226 int i;

227 for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {

228 MMCOOpcode opcode = get_ue_golomb_31(gb);

229 if (opcode > (unsigned) MMCO_LONG) {

230 av_log(logctx, AV_LOG_ERROR,

231 "illegal memory management control operation %d\n",

232 opcode);

233 return AVERROR_INVALIDDATA;

234 }

235 if (opcode == MMCO_END)

236 return 0;

237 else if (opcode == MMCO_RESET)

238 return 1;

239

240 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)

241 get_ue_golomb_long(gb); // difference_of_pic_nums_minus1

242 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||

243 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)

244 get_ue_golomb_31(gb);

245 }

246 }

247

248 return 0;

249 }

250

251 /**

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

253 *

254 * @param s parser context.

255 * @param avctx codec context.

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

257 * @param buf_size size of the buffer.

258 */

259 static inline int parse_nal_units(AVCodecParserContext *s,

260 AVCodecContext *avctx,

261 const uint8_t * const buf, int buf_size)

262 {

263 H264ParseContext *p = s->priv_data;

264 H2645RBSP rbsp = { NULL };

265 H2645NAL nal = { NULL };

266 int buf_index, next_avc;

267 unsigned int pps_id;

268 unsigned int slice_type;

269 int state = -1, got_reset = 0;

270 int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);

271 int field_poc[2];

272 int ret;

273

274 /* set some sane default values */

275 s->pict_type = AV_PICTURE_TYPE_I;

276 s->key_frame = 0;

277 s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;

278

279 ff_h264_sei_uninit(&p->sei);

280 p->sei.common.frame_packing.arrangement_cancel_flag = -1;

281 p->sei.common.unregistered.x264_build = -1;

282

283 if (!buf_size)

284 return 0;

285

286 av_fast_padded_malloc(&rbsp.rbsp_buffer, &rbsp.rbsp_buffer_alloc_size, buf_size);

287 if (!rbsp.rbsp_buffer)

288 return AVERROR(ENOMEM);

289

290 buf_index = 0;

291 next_avc = p->is_avc ? 0 : buf_size;

292 for (;;) {

293 const SPS *sps;

294 int src_length, consumed, nalsize = 0;

295

296 if (buf_index >= next_avc) {

297 nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);

298 if (nalsize < 0)

299 break;

300 next_avc = buf_index + nalsize;

301 } else {

302 buf_index = find_start_code(buf, buf_size, buf_index, next_avc);

303 if (buf_index >= buf_size)

304 break;

305 if (buf_index >= next_avc)

306 continue;

307 }

308 src_length = next_avc - buf_index;

309

310 state = buf[buf_index];

311 switch (state & 0x1f) {

312 case H264_NAL_SLICE:

313 case H264_NAL_IDR_SLICE:

314 // Do not walk the whole buffer just to decode slice header

315 if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {

316 /* IDR or disposable slice

317 * No need to decode many bytes because MMCOs shall not be present. */

318 if (src_length > 60)

319 src_length = 60;

320 } else {

321 /* To decode up to MMCOs */

322 if (src_length > 1000)

323 src_length = 1000;

324 }

325 break;

326 }

327 consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1);

328 if (consumed < 0)

329 break;

330

331 buf_index += consumed;

332

333 ret = init_get_bits8(&nal.gb, nal.data, nal.size);

334 if (ret < 0)

335 goto fail;

336 get_bits1(&nal.gb);

337 nal.ref_idc = get_bits(&nal.gb, 2);

338 nal.type = get_bits(&nal.gb, 5);

339

340 switch (nal.type) {

341 case H264_NAL_SPS:

342 ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);

343 break;

344 case H264_NAL_PPS:

345 ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,

346 nal.size_bits);

347 break;

348 case H264_NAL_SEI:

349 ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);

350 break;

351 case H264_NAL_IDR_SLICE:

352 s->key_frame = 1;

353

354 p->poc.prev_frame_num = 0;

355 p->poc.prev_frame_num_offset = 0;

356 p->poc.prev_poc_msb =

357 p->poc.prev_poc_lsb = 0;

358 /* fall through */

359 case H264_NAL_SLICE:

360 get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice

361 slice_type = get_ue_golomb_31(&nal.gb);

362 s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];

363 if (p->sei.recovery_point.recovery_frame_cnt >= 0) {

364 /* key frame, since recovery_frame_cnt is set */

365 s->key_frame = 1;

366 }

367 pps_id = get_ue_golomb(&nal.gb);

368 if (pps_id >= MAX_PPS_COUNT) {

369 av_log(avctx, AV_LOG_ERROR,

370 "pps_id %u out of range\n", pps_id);

371 goto fail;

372 }

373 if (!p->ps.pps_list[pps_id]) {

374 av_log(avctx, AV_LOG_ERROR,

375 "non-existing PPS %u referenced\n", pps_id);

376 goto fail;

377 }

378

379 av_refstruct_replace(&p->ps.pps, p->ps.pps_list[pps_id]);

380 p->ps.sps = p->ps.pps->sps;

381 sps = p->ps.sps;

382

383 // heuristic to detect non marked keyframes

384 if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)

385 s->key_frame = 1;

386

387 p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);

388

389 s->coded_width = 16 * sps->mb_width;

390 s->coded_height = 16 * sps->mb_height;

391 s->width = s->coded_width - (sps->crop_right + sps->crop_left);

392 s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);

393 if (s->width <= 0 || s->height <= 0) {

394 s->width = s->coded_width;

395 s->height = s->coded_height;

396 }

397

398 switch (sps->bit_depth_luma) {

399 case 9:

400 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;

401 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;

402 else s->format = AV_PIX_FMT_YUV420P9;

403 break;

404 case 10:

405 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;

406 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;

407 else s->format = AV_PIX_FMT_YUV420P10;

408 break;

409 case 8:

410 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;

411 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;

412 else s->format = AV_PIX_FMT_YUV420P;

413 break;

414 default:

415 s->format = AV_PIX_FMT_NONE;

416 }

417

418 avctx->profile = ff_h264_get_profile(sps);

419 avctx->level = sps->level_idc;

420

421 if (sps->frame_mbs_only_flag) {

422 p->picture_structure = PICT_FRAME;

423 } else {

424 if (get_bits1(&nal.gb)) { // field_pic_flag

425 p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag

426 } else {

427 p->picture_structure = PICT_FRAME;

428 }

429 }

430

431 if (nal.type == H264_NAL_IDR_SLICE)

432 get_ue_golomb_long(&nal.gb); /* idr_pic_id */

433 if (sps->poc_type == 0) {

434 p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);

435

436 if (p->ps.pps->pic_order_present == 1 &&

437 p->picture_structure == PICT_FRAME)

438 p->poc.delta_poc_bottom = get_se_golomb(&nal.gb);

439 }

440

441 if (sps->poc_type == 1 &&

442 !sps->delta_pic_order_always_zero_flag) {

443 p->poc.delta_poc[0] = get_se_golomb(&nal.gb);

444

445 if (p->ps.pps->pic_order_present == 1 &&

446 p->picture_structure == PICT_FRAME)

447 p->poc.delta_poc[1] = get_se_golomb(&nal.gb);

448 }

449

450 /* Decode POC of this picture.

451 * The prev_ values needed for decoding POC of the next picture are not set here. */

452 field_poc[0] = field_poc[1] = INT_MAX;

453 ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,

454 &p->poc, p->picture_structure, nal.ref_idc);

455 if (ret < 0)

456 goto fail;

457

458 /* Continue parsing to check if MMCO_RESET is present.

459 * FIXME: MMCO_RESET could appear in non-first slice.

460 * Maybe, we should parse all undisposable non-IDR slice of this

461 * picture until encountering MMCO_RESET in a slice of it. */

462 if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {

463 got_reset = scan_mmco_reset(s, &nal.gb, avctx);

464 if (got_reset < 0)

465 goto fail;

466 }

467

468 /* Set up the prev_ values for decoding POC of the next picture. */

469 p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;

470 p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;

471 if (nal.ref_idc != 0) {

472 if (!got_reset) {

473 p->poc.prev_poc_msb = p->poc.poc_msb;

474 p->poc.prev_poc_lsb = p->poc.poc_lsb;

475 } else {

476 p->poc.prev_poc_msb = 0;

477 p->poc.prev_poc_lsb =

478 p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];

479 }

480 }

481

482 if (p->sei.picture_timing.present) {

483 ret = ff_h264_sei_process_picture_timing(&p->sei.picture_timing,

484 sps, avctx);

485 if (ret < 0) {

486 av_log(avctx, AV_LOG_ERROR, "Error processing the picture timing SEI\n");

487 p->sei.picture_timing.present = 0;

488 }

489 }

490

491 if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {

492 switch (p->sei.picture_timing.pic_struct) {

493 case H264_SEI_PIC_STRUCT_TOP_FIELD:

494 case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:

495 s->repeat_pict = 0;

496 break;

497 case H264_SEI_PIC_STRUCT_FRAME:

498 case H264_SEI_PIC_STRUCT_TOP_BOTTOM:

499 case H264_SEI_PIC_STRUCT_BOTTOM_TOP:

500 s->repeat_pict = 1;

501 break;

502 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

503 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

504 s->repeat_pict = 2;

505 break;

506 case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:

507 s->repeat_pict = 3;

508 break;

509 case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:

510 s->repeat_pict = 5;

511 break;

512 default:

513 s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;

514 break;

515 }

516 } else {

517 s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;

518 }

519

520 if (p->picture_structure == PICT_FRAME) {

521 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

522 if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {

523 switch (p->sei.picture_timing.pic_struct) {

524 case H264_SEI_PIC_STRUCT_TOP_BOTTOM:

525 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

526 s->field_order = AV_FIELD_TT;

527 break;

528 case H264_SEI_PIC_STRUCT_BOTTOM_TOP:

529 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

530 s->field_order = AV_FIELD_BB;

531 break;

532 default:

533 s->field_order = AV_FIELD_PROGRESSIVE;

534 break;

535 }

536 } else {

537 if (field_poc[0] < field_poc[1])

538 s->field_order = AV_FIELD_TT;

539 else if (field_poc[0] > field_poc[1])

540 s->field_order = AV_FIELD_BB;

541 else

542 s->field_order = AV_FIELD_PROGRESSIVE;

543 }

544 } else {

545 if (p->picture_structure == PICT_TOP_FIELD)

546 s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;

547 else

548 s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;

549 if (p->poc.frame_num == p->last_frame_num &&

550 p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&

551 p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&

552 p->last_picture_structure != s->picture_structure) {

553 if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)

554 s->field_order = AV_FIELD_TT;

555 else

556 s->field_order = AV_FIELD_BB;

557 } else {

558 s->field_order = AV_FIELD_UNKNOWN;

559 }

560 p->last_picture_structure = s->picture_structure;

561 p->last_frame_num = p->poc.frame_num;

562 }

563 if (sps->timing_info_present_flag) {

564 int64_t den = sps->time_scale;

565 if (p->sei.common.unregistered.x264_build < 44U)

566 den *= 2;

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

568 sps->num_units_in_tick * 2, den, 1 << 30);

569 }

570

571 av_freep(&rbsp.rbsp_buffer);

572 return 0; /* no need to evaluate the rest */

573 }

574 }

575 if (q264) {

576 av_freep(&rbsp.rbsp_buffer);

577 return 0;

578 }

579 /* didn't find a picture! */

580 av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);

581 fail:

582 av_freep(&rbsp.rbsp_buffer);

583 return -1;

584 }

585

586 static int h264_parse(AVCodecParserContext *s,

587 AVCodecContext *avctx,

588 const uint8_t **poutbuf, int *poutbuf_size,

589 const uint8_t *buf, int buf_size)

590 {

591 H264ParseContext *p = s->priv_data;

592 ParseContext *pc = &p->pc;

593 AVRational time_base = { 0, 1 };

594 int next;

595

596 if (!p->got_first) {

597 p->got_first = 1;

598 if (avctx->extradata_size) {

599 ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,

600 &p->ps, &p->is_avc, &p->nal_length_size,

601 avctx->err_recognition, avctx);

602 }

603 }

604

605 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

606 next = buf_size;

607 } else {

608 next = h264_find_frame_end(p, buf, buf_size, avctx);

609

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

611 *poutbuf = NULL;

612 *poutbuf_size = 0;

613 return buf_size;

614 }

615

616 if (next < 0 && next != END_NOT_FOUND) {

617 av_assert1(pc->last_index + next >= 0);

618 h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state

619 }

620 }

621

622 parse_nal_units(s, avctx, buf, buf_size);

623

624 if (avctx->framerate.num)

625 time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){2, 1}));

626 if (p->sei.picture_timing.cpb_removal_delay >= 0) {

627 s->dts_sync_point = p->sei.buffering_period.present;

628 s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;

629 s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay;

630 } else {

631 s->dts_sync_point = INT_MIN;

632 s->dts_ref_dts_delta = INT_MIN;

633 s->pts_dts_delta = INT_MIN;

634 }

635

636 if (s->flags & PARSER_FLAG_ONCE) {

637 s->flags &= PARSER_FLAG_COMPLETE_FRAMES;

638 }

639

640 if (s->dts_sync_point >= 0) {

641 int64_t den = time_base.den * (int64_t)avctx->pkt_timebase.num;

642 if (den > 0) {

643 int64_t num = time_base.num * (int64_t)avctx->pkt_timebase.den;

644 if (s->dts != AV_NOPTS_VALUE) {

645 // got DTS from the stream, update reference timestamp

646 p->reference_dts = av_sat_sub64(s->dts, av_rescale(s->dts_ref_dts_delta, num, den));

647 } else if (p->reference_dts != AV_NOPTS_VALUE) {

648 // compute DTS based on reference timestamp

649 s->dts = av_sat_add64(p->reference_dts, av_rescale(s->dts_ref_dts_delta, num, den));

650 }

651

652 if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)

653 s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);

654

655 if (s->dts_sync_point > 0)

656 p->reference_dts = s->dts; // new reference

657 }

658 }

659

660 *poutbuf = buf;

661 *poutbuf_size = buf_size;

662 return next;

663 }

664

665 static av_cold void h264_close(AVCodecParserContext *s)

666 {

667 H264ParseContext *p = s->priv_data;

668 ParseContext *pc = &p->pc;

669

670 av_freep(&pc->buffer);

671

672 ff_h264_sei_uninit(&p->sei);

673 ff_h264_ps_uninit(&p->ps);

674 }

675

676 static av_cold int init(AVCodecParserContext *s)

677 {

678 H264ParseContext *p = s->priv_data;

679

680 p->reference_dts = AV_NOPTS_VALUE;

681 p->last_frame_num = INT_MAX;

682 ff_h264dsp_init(&p->h264dsp, 8, 1);

683 return 0;

684 }

685

686 const FFCodecParser ff_h264_parser = {

687 PARSER_CODEC_LIST(AV_CODEC_ID_H264),

688 .priv_data_size = sizeof(H264ParseContext),

689 .init = init,

690 .parse = h264_parse,

691 .close = h264_close,

692 };

MMCO_LONG2UNUSED

@ MMCO_LONG2UNUSED

Definition: h264_parse.h:62

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:33

H264ParseContext

Definition: h264_parser.c:55

MMCO_LONG

@ MMCO_LONG

Definition: h264_parse.h:66

ff_h264_sei_uninit

void ff_h264_sei_uninit(H264SEIContext *h)

Reset SEI values at the beginning of the frame.

Definition: h264_sei.c:48

h2645_parse.h

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:694

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

H264ParseContext::sei

H264SEIContext sei

Definition: h264_parser.c:60

ff_h264_ps_uninit

void ff_h264_ps_uninit(H264ParamSets *ps)

Uninit H264 param sets structure.

Definition: h264_ps.c:270

h264_close

static av_cold void h264_close(AVCodecParserContext *s)

Definition: h264_parser.c:665

H264ParseContext::parse_last_mb

int parse_last_mb

Definition: h264_parser.c:67

AV_FIELD_PROGRESSIVE

@ AV_FIELD_PROGRESSIVE

Definition: defs.h:213

AV_PICTURE_STRUCTURE_UNKNOWN

@ AV_PICTURE_STRUCTURE_UNKNOWN

unknown

Definition: avcodec.h:2569

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1398

int64_t

long long int64_t

Definition: coverity.c:34

H264ParseContext::is_avc

int is_avc

Definition: h264_parser.c:61

H264_SEI_PIC_STRUCT_TOP_BOTTOM

@ H264_SEI_PIC_STRUCT_TOP_BOTTOM

3: top field, bottom field, in that order

Definition: h264_sei.h:35

H2645NAL::ref_idc

int ref_idc

H.264 only, nal_ref_idc.

Definition: h2645_parse.h:57

scan_mmco_reset

static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, void *logctx)

Definition: h264_parser.c:173

h264_parse.h

parser_internal.h

get_ue_golomb

static int get_ue_golomb(GetBitContext *gb)

Read an unsigned Exp-Golomb code in the range 0 to 8190.

Definition: golomb.h:53

H264ParseContext::parse_history

uint8_t parse_history[6]

Definition: h264_parser.c:65

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:539

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:32

ff_h264_pred_weight_table

int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)

Definition: h264_parse.c:30

H264ParseContext::picture_structure

int picture_structure

Definition: h264_parser.c:64

mpegutils.h

MMCOOpcode

Memory management control operation opcode.

Definition: h264_parse.h:59

ParseContext::state

uint32_t state

contains the last few bytes in MSB order

Definition: parser.h:33

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:517

ParseContext::last_index

int last_index

Definition: parser.h:31

H264ParseContext::got_first

int got_first

Definition: h264_parser.c:63

H2645NAL::size_bits

int size_bits

Size, in bits, of just the data, excluding the stop bit and any trailing padding.

Definition: h2645_parse.h:42

ff_h264_decode_picture_parameter_set

int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)

Decode PPS.

Definition: h264_ps.c:696

MMCO_SET_MAX_LONG

@ MMCO_SET_MAX_LONG

Definition: h264_parse.h:64

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:551

golomb.h

exp golomb vlc stuff

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:337

AV_FIELD_TT

@ AV_FIELD_TT

Top coded_first, top displayed first.

Definition: defs.h:214

ParseContext

Definition: parser.h:28

H264ParseContext::h264dsp

H264DSPContext h264dsp

Definition: h264_parser.c:58

fail

#define fail()

Definition: checkasm.h:207

H264_MAX_MMCO_COUNT

@ H264_MAX_MMCO_COUNT

Definition: h264.h:92

ff_h264_sei_decode

int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)

Definition: h264_sei.c:230

H264_NAL_SLICE

@ H264_NAL_SLICE

Definition: h264.h:35

GetBitContext

Definition: get_bits.h:109

AV_PIX_FMT_YUV422P9

#define AV_PIX_FMT_YUV422P9

Definition: pixfmt.h:537

ff_h264_sei_process_picture_timing

int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)

Parse the contents of a picture timing message given an active SPS.

Definition: h264_sei.c:64

ff_h264_golomb_to_pict_type

const uint8_t ff_h264_golomb_to_pict_type[5]

Definition: h264data.c:37

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

parse_nal_units

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

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

Definition: h264_parser.c:259

refstruct.h

state

static struct @542 state

h264_parse

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

Definition: h264_parser.c:586

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:542

ParseContext::buffer

uint8_t * buffer

Definition: parser.h:29

AV_PICTURE_STRUCTURE_FRAME

@ AV_PICTURE_STRUCTURE_FRAME

coded as frame

Definition: avcodec.h:2572

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:544

AV_FIELD_UNKNOWN

@ AV_FIELD_UNKNOWN

Definition: defs.h:212

H2645NAL::size

int size

Definition: h2645_parse.h:36

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

#define s(width, name)

Definition: cbs_vp9.c:198

ff_h264_decode_extradata

int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)

Definition: h264_parse.c:466

h264data.h

AV_PIX_FMT_YUV420P9

#define AV_PIX_FMT_YUV420P9

Definition: pixfmt.h:536

PICT_TOP_FIELD

#define PICT_TOP_FIELD

Definition: mpegutils.h:31

get_bits.h

H2645NAL::data

const uint8_t * data

Definition: h2645_parse.h:35

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

get_se_golomb

static int get_se_golomb(GetBitContext *gb)

read signed exp golomb code.

Definition: golomb.h:239

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

H2645NAL::type

int type

NAL unit type.

Definition: h2645_parse.h:52

H264_NAL_SPS

@ H264_NAL_SPS

Definition: h264.h:41

ff_h264_parser

const FFCodecParser ff_h264_parser

Definition: h264_parser.c:686

if(ret)

Definition: filter_design.txt:179

AV_PICTURE_STRUCTURE_BOTTOM_FIELD

@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD

coded as bottom field

Definition: avcodec.h:2571

NULL

#define NULL

Definition: coverity.c:32

H264SEIContext

Definition: h264_sei.h:119

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

SPS

Sequence parameter set.

Definition: h264_ps.h:44

AV_PICTURE_STRUCTURE_TOP_FIELD

@ AV_PICTURE_STRUCTURE_TOP_FIELD

coded as top field

Definition: avcodec.h:2570

H264_NAL_AUD

@ H264_NAL_AUD

Definition: h264.h:43

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:391

h264dsp.h

ParseContext::frame_start_found

int frame_start_found

Definition: parser.h:34

list

Definition: filter_design.txt:25

avpriv_find_start_code

const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)

MAX_PPS_COUNT

#define MAX_PPS_COUNT

Definition: h264_ps.h:38

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:540

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

h264_find_frame_end

static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf, int buf_size, void *logctx)

Definition: h264_parser.c:82

h264_ps.h

index

int index

Definition: gxfenc.c:90

error.h

H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM

@ H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM

6: bottom field, top field, bottom field repeated, in that order

Definition: h264_sei.h:38

H2645RBSP::rbsp_buffer

uint8_t * rbsp_buffer

Definition: h2645_parse.h:75

startcode.h

H264DSPContext

Context for storing H.264 DSP functions.

Definition: h264dsp.h:42

av_sat_sub64

#define av_sat_sub64

Definition: common.h:142

MMCO_END

@ MMCO_END

Definition: h264_parse.h:60

H264_NAL_PPS

@ H264_NAL_PPS

Definition: h264.h:42

AVCodecContext::pkt_timebase

AVRational pkt_timebase

Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.

Definition: avcodec.h:542

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:247

H264_SEI_PIC_STRUCT_BOTTOM_TOP

@ H264_SEI_PIC_STRUCT_BOTTOM_TOP

4: bottom field, top field, in that order

Definition: h264_sei.h:36

H2645NAL::gb

GetBitContext gb

Definition: h2645_parse.h:47

MMCO_SHORT2UNUSED

@ MMCO_SHORT2UNUSED

Definition: h264_parse.h:61

H2645NAL

Definition: h2645_parse.h:34

MMCO_RESET

@ MMCO_RESET

Definition: h264_parse.h:65

H264ParseContext::parse_history_count

int parse_history_count

Definition: h264_parser.c:66

H264ParseContext::last_frame_num

int last_frame_num

Definition: h264_parser.c:69

attributes.h

#define mb

Definition: vf_colormatrix.c:99

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

H264_SEI_PIC_STRUCT_FRAME

@ H264_SEI_PIC_STRUCT_FRAME

0: frame

Definition: h264_sei.h:32

H264_SEI_PIC_STRUCT_FRAME_TRIPLING

@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING

8: frame tripling

Definition: h264_sei.h:40

h264_sei.h

ff_h264_decode_seq_parameter_set

int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)

Decode SPS.

Definition: h264_ps.c:284

log.h

PARSER_FLAG_COMPLETE_FRAMES

#define PARSER_FLAG_COMPLETE_FRAMES

Definition: avcodec.h:2609

MMCO_SHORT2LONG

@ MMCO_SHORT2LONG

Definition: h264_parse.h:63

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

Definition: cbs_h2645.c:256

H264_SEI_PIC_STRUCT_FRAME_DOUBLING

@ H264_SEI_PIC_STRUCT_FRAME_DOUBLING

7: frame doubling

Definition: h264_sei.h:39

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

ff_h2645_extract_rbsp

int ff_h2645_extract_rbsp(const uint8_t *src, int length, H2645RBSP *rbsp, H2645NAL *nal, int small_padding)

Extract the raw (unescaped) bitstream.

Definition: h2645_parse.c:37

H264POCContext

Definition: h264_parse.h:82

AV_FIELD_BB

@ AV_FIELD_BB

Bottom coded first, bottom displayed first.

Definition: defs.h:215

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:57

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:53

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

parser.h

ff_h264_parse_ref_count

int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)

Definition: h264_parse.c:222

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

H264ParseContext::last_picture_structure

int last_picture_structure

Definition: h264_parser.c:69

PARSER_CODEC_LIST

#define PARSER_CODEC_LIST(...)

Definition: parser_internal.h:76

AV_PIX_FMT_YUV444P9

#define AV_PIX_FMT_YUV444P9

Definition: pixfmt.h:538

H2645RBSP::rbsp_buffer_alloc_size

int rbsp_buffer_alloc_size

Definition: h2645_parse.h:77

avcodec.h

AVCodecParserContext

Definition: avcodec.h:2575

ff_h264dsp_init

av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)

Definition: h264dsp.c:66

ret

Definition: filter_design.txt:187

ff_h264_init_poc

int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)

Definition: h264_parse.c:280

pixfmt.h

ff_h264_get_profile

int ff_h264_get_profile(const SPS *sps)

Compute profile from profile_idc and constraint_set?_flags.

Definition: h264_parse.c:533

H264_NAL_SEI

@ H264_NAL_SEI

Definition: h264.h:40

sps

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

Definition: cbs_h264_syntax_template.c:260

av_sat_add64

#define av_sat_add64

Definition: common.h:139

#define U(x)

Definition: vpx_arith.h:37

AVCodecContext

main external API structure.

Definition: avcodec.h:431

get_ue_golomb_31

static int get_ue_golomb_31(GetBitContext *gb)

read unsigned exp golomb code, constraint to a max of 31.

Definition: golomb.h:120

find_start_code

static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)

Definition: h264_parser.c:72

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:280

av_refstruct_replace

void av_refstruct_replace(void *dstp, const void *src)

Ensure *dstp refers to the same object as src.

Definition: refstruct.c:160

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

H264ParseContext::nal_length_size

int nal_length_size

Definition: h264_parser.c:62

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1618

H264ParamSets

Definition: h264_ps.h:144

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

av_mul_q

AVRational av_mul_q(AVRational b, AVRational c)

Multiply two rationals.

Definition: rational.c:80

H264PredWeightTable

Definition: h264_parse.h:69

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

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:279

avutil.h

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

init

static av_cold int init(AVCodecParserContext *s)

Definition: h264_parser.c:676

get_ue_golomb_long

static unsigned get_ue_golomb_long(GetBitContext *gb)

Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.

Definition: golomb.h:104

H264_SEI_PIC_STRUCT_BOTTOM_FIELD

@ H264_SEI_PIC_STRUCT_BOTTOM_FIELD

2: bottom field

Definition: h264_sei.h:34

H264ParseContext::ps

H264ParamSets ps

Definition: h264_parser.c:57

H264ParseContext::poc

H264POCContext poc

Definition: h264_parser.c:59

END_NOT_FOUND

#define END_NOT_FOUND

Definition: parser.h:40

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

H264_NAL_DPA

@ H264_NAL_DPA

Definition: h264.h:36

h264.h

get_nalsize

static int get_nalsize(int nal_length_size, const uint8_t *buf, int buf_size, int *buf_index, void *logctx)

Definition: h2645_parse.h:126

H264ParseContext::reference_dts

int64_t reference_dts

Definition: h264_parser.c:68

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

PARSER_FLAG_ONCE

#define PARSER_FLAG_ONCE

Definition: avcodec.h:2610

H2645RBSP

Definition: h2645_parse.h:74

H264_NAL_IDR_SLICE

@ H264_NAL_IDR_SLICE

Definition: h264.h:39

H264_SEI_PIC_STRUCT_TOP_FIELD

@ H264_SEI_PIC_STRUCT_TOP_FIELD

1: top field

Definition: h264_sei.h:33

H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP

@ H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP

5: top field, bottom field, top field repeated, in that order

Definition: h264_sei.h:37

H264ParseContext::pc

ParseContext pc

Definition: h264_parser.c:56

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