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/avutil.h"

33 #include "libavutil/error.h"

34 #include "libavutil/log.h"

35 #include "libavutil/mem.h"

36 #include "libavutil/pixfmt.h"

38 #include "avcodec.h"

39 #include "get_bits.h"

40 #include "golomb.h"

41 #include "h264.h"

42 #include "h264dsp.h"

43 #include "h264_parse.h"

44 #include "h264_sei.h"

45 #include "h264_ps.h"

46 #include "h2645_parse.h"

47 #include "h264data.h"

48 #include "mpegutils.h"

49 #include "parser.h"

50 #include "refstruct.h"

51 #include "startcode.h"

53 typedef struct H264ParseContext {

54 ParseContext pc;

55 H264ParamSets ps;

56 H264DSPContext h264dsp;

57 H264POCContext poc;

58 H264SEIContext sei;

59 int is_avc;

60 int nal_length_size;

61 int got_first;

62 int picture_structure;

63 uint8_t parse_history[6];

64 int parse_history_count;

65 int parse_last_mb;

66 int64_t reference_dts;

67 int last_frame_num, last_picture_structure;

68 } H264ParseContext;

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

71 int buf_index, int next_avc)

72 {

73 uint32_t state = -1;

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

77 return FFMIN(buf_index, buf_size);

78 }

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

81 int buf_size, void *logctx)

82 {

83 int i, j;

84 uint32_t state;

85 ParseContext *pc = &p->pc;

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

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

89 state = pc->state;

90 if (state > 13)

91 state = 7;

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

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

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

97 if (i >= next_avc) {

98 int64_t nalsize = 0;

99 i = next_avc;

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

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

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

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

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

105 return buf_size;

106 }

107 next_avc = i + nalsize;

108 state = 5;

109 }

110

111 if (state == 7) {

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

113 if (i < next_avc)

114 state = 2;

115 } else if (state <= 2) {

116 if (buf[i] == 1)

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

118 else if (buf[i])

119 state = 7;

120 else

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

122 } else if (state <= 5) {

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

124 if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||

125 nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {

126 if (pc->frame_start_found) {

127 i++;

128 goto found;

129 }

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

131 nalu_type == H264_NAL_IDR_SLICE) {

132 state += 8;

133 continue;

134 }

135 state = 7;

136 } else {

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

138 GetBitContext gb;

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

140

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

142 mb= get_ue_golomb_long(&gb);

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

144 p->parse_last_mb = mb;

145 if (pc->frame_start_found) {

146 if (mb <= last_mb) {

147 i -= p->parse_history_count - 1;

148 p->parse_history_count = 0;

149 goto found;

150 }

151 } else

152 pc->frame_start_found = 1;

153 p->parse_history_count = 0;

154 state = 7;

155 }

156 }

157 }

158 pc->state = state;

159 if (p->is_avc)

160 return next_avc;

161 return END_NOT_FOUND;

162

163 found:

164 pc->state = 7;

165 pc->frame_start_found = 0;

166 if (p->is_avc)

167 return next_avc;

168 return i - (state & 5);

169 }

170

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

172 void *logctx)

173 {

174 H264PredWeightTable pwt;

175 int slice_type_nos = s->pict_type & 3;

176 H264ParseContext *p = s->priv_data;

177 int list_count, ref_count[2];

178

179

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

181 get_ue_golomb(gb); // redundant_pic_count

182

183 if (slice_type_nos == AV_PICTURE_TYPE_B)

184 get_bits1(gb); // direct_spatial_mv_pred

185

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

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

188 return AVERROR_INVALIDDATA;

189

190 if (slice_type_nos != AV_PICTURE_TYPE_I) {

191 int list;

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

193 if (get_bits1(gb)) {

194 int index;

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

196 unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);

197

198 if (reordering_of_pic_nums_idc < 3)

199 get_ue_golomb_long(gb);

200 else if (reordering_of_pic_nums_idc > 3) {

201 av_log(logctx, AV_LOG_ERROR,

202 "illegal reordering_of_pic_nums_idc %d\n",

203 reordering_of_pic_nums_idc);

204 return AVERROR_INVALIDDATA;

205 } else

206 break;

207

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

209 av_log(logctx, AV_LOG_ERROR,

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

211 return AVERROR_INVALIDDATA;

212 }

213 }

214 }

215 }

216 }

217

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

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

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

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

222

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

224 int i;

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

226 MMCOOpcode opcode = get_ue_golomb_31(gb);

227 if (opcode > (unsigned) MMCO_LONG) {

228 av_log(logctx, AV_LOG_ERROR,

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

230 opcode);

231 return AVERROR_INVALIDDATA;

232 }

233 if (opcode == MMCO_END)

234 return 0;

235 else if (opcode == MMCO_RESET)

236 return 1;

237

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

239 get_ue_golomb_long(gb); // difference_of_pic_nums_minus1

240 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||

241 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)

242 get_ue_golomb_31(gb);

243 }

244 }

245

246 return 0;

247 }

248

249 /**

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

251 *

252 * @param s parser context.

253 * @param avctx codec context.

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

255 * @param buf_size size of the buffer.

256 */

257 static inline int parse_nal_units(AVCodecParserContext *s,

258 AVCodecContext *avctx,

259 const uint8_t * const buf, int buf_size)

260 {

261 H264ParseContext *p = s->priv_data;

262 H2645RBSP rbsp = { NULL };

263 H2645NAL nal = { NULL };

264 int buf_index, next_avc;

265 unsigned int pps_id;

266 unsigned int slice_type;

267 int state = -1, got_reset = 0;

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

269 int field_poc[2];

270 int ret;

271

272 /* set some sane default values */

273 s->pict_type = AV_PICTURE_TYPE_I;

274 s->key_frame = 0;

275 s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;

276

277 ff_h264_sei_uninit(&p->sei);

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

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

280

281 if (!buf_size)

282 return 0;

283

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

285 if (!rbsp.rbsp_buffer)

286 return AVERROR(ENOMEM);

287

288 buf_index = 0;

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

290 for (;;) {

291 const SPS *sps;

292 int src_length, consumed, nalsize = 0;

293

294 if (buf_index >= next_avc) {

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

296 if (nalsize < 0)

297 break;

298 next_avc = buf_index + nalsize;

299 } else {

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

301 if (buf_index >= buf_size)

302 break;

303 if (buf_index >= next_avc)

304 continue;

305 }

306 src_length = next_avc - buf_index;

307

308 state = buf[buf_index];

309 switch (state & 0x1f) {

310 case H264_NAL_SLICE:

311 case H264_NAL_IDR_SLICE:

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

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

314 /* IDR or disposable slice

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

316 if (src_length > 60)

317 src_length = 60;

318 } else {

319 /* To decode up to MMCOs */

320 if (src_length > 1000)

321 src_length = 1000;

322 }

323 break;

324 }

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

326 if (consumed < 0)

327 break;

328

329 buf_index += consumed;

330

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

332 if (ret < 0)

333 goto fail;

334 get_bits1(&nal.gb);

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

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

337

338 switch (nal.type) {

339 case H264_NAL_SPS:

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

341 break;

342 case H264_NAL_PPS:

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

344 nal.size_bits);

345 break;

346 case H264_NAL_SEI:

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

348 break;

349 case H264_NAL_IDR_SLICE:

350 s->key_frame = 1;

351

352 p->poc.prev_frame_num = 0;

353 p->poc.prev_frame_num_offset = 0;

354 p->poc.prev_poc_msb =

355 p->poc.prev_poc_lsb = 0;

356 /* fall through */

357 case H264_NAL_SLICE:

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

359 slice_type = get_ue_golomb_31(&nal.gb);

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

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

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

363 s->key_frame = 1;

364 }

365 pps_id = get_ue_golomb(&nal.gb);

366 if (pps_id >= MAX_PPS_COUNT) {

367 av_log(avctx, AV_LOG_ERROR,

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

369 goto fail;

370 }

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

372 av_log(avctx, AV_LOG_ERROR,

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

374 goto fail;

375 }

376

377 ff_refstruct_replace(&p->ps.pps, p->ps.pps_list[pps_id]);

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

379 sps = p->ps.sps;

380

381 // heuristic to detect non marked keyframes

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

383 s->key_frame = 1;

384

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

386

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

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

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

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

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

392 s->width = s->coded_width;

393 s->height = s->coded_height;

394 }

395

396 switch (sps->bit_depth_luma) {

397 case 9:

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

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

400 else s->format = AV_PIX_FMT_YUV420P9;

401 break;

402 case 10:

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

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

405 else s->format = AV_PIX_FMT_YUV420P10;

406 break;

407 case 8:

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

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

410 else s->format = AV_PIX_FMT_YUV420P;

411 break;

412 default:

413 s->format = AV_PIX_FMT_NONE;

414 }

415

416 avctx->profile = ff_h264_get_profile(sps);

417 avctx->level = sps->level_idc;

418

419 if (sps->frame_mbs_only_flag) {

420 p->picture_structure = PICT_FRAME;

421 } else {

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

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

424 } else {

425 p->picture_structure = PICT_FRAME;

426 }

427 }

428

429 if (nal.type == H264_NAL_IDR_SLICE)

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

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

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

433

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

435 p->picture_structure == PICT_FRAME)

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

437 }

438

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

440 !sps->delta_pic_order_always_zero_flag) {

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

442

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

444 p->picture_structure == PICT_FRAME)

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

446 }

447

448 /* Decode POC of this picture.

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

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

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

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

453 if (ret < 0)

454 goto fail;

455

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

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

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

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

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

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

462 if (got_reset < 0)

463 goto fail;

464 }

465

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

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

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

469 if (nal.ref_idc != 0) {

470 if (!got_reset) {

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

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

473 } else {

474 p->poc.prev_poc_msb = 0;

475 p->poc.prev_poc_lsb =

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

477 }

478 }

479

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

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

482 sps, avctx);

483 if (ret < 0) {

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

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

486 }

487 }

488

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

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

491 case H264_SEI_PIC_STRUCT_TOP_FIELD:

492 case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:

493 s->repeat_pict = 0;

494 break;

495 case H264_SEI_PIC_STRUCT_FRAME:

496 case H264_SEI_PIC_STRUCT_TOP_BOTTOM:

497 case H264_SEI_PIC_STRUCT_BOTTOM_TOP:

498 s->repeat_pict = 1;

499 break;

500 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

501 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

502 s->repeat_pict = 2;

503 break;

504 case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:

505 s->repeat_pict = 3;

506 break;

507 case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:

508 s->repeat_pict = 5;

509 break;

510 default:

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

512 break;

513 }

514 } else {

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

516 }

517

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

519 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

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

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

522 case H264_SEI_PIC_STRUCT_TOP_BOTTOM:

523 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

524 s->field_order = AV_FIELD_TT;

525 break;

526 case H264_SEI_PIC_STRUCT_BOTTOM_TOP:

527 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

528 s->field_order = AV_FIELD_BB;

529 break;

530 default:

531 s->field_order = AV_FIELD_PROGRESSIVE;

532 break;

533 }

534 } else {

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

536 s->field_order = AV_FIELD_TT;

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

538 s->field_order = AV_FIELD_BB;

539 else

540 s->field_order = AV_FIELD_PROGRESSIVE;

541 }

542 } else {

543 if (p->picture_structure == PICT_TOP_FIELD)

544 s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;

545 else

546 s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;

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

548 p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&

549 p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&

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

551 if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)

552 s->field_order = AV_FIELD_TT;

553 else

554 s->field_order = AV_FIELD_BB;

555 } else {

556 s->field_order = AV_FIELD_UNKNOWN;

557 }

558 p->last_picture_structure = s->picture_structure;

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

560 }

561 if (sps->timing_info_present_flag) {

562 int64_t den = sps->time_scale;

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

564 den *= 2;

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

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

567 }

568

569 av_freep(&rbsp.rbsp_buffer);

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

571 }

572 }

573 if (q264) {

574 av_freep(&rbsp.rbsp_buffer);

575 return 0;

576 }

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

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

579 fail:

580 av_freep(&rbsp.rbsp_buffer);

581 return -1;

582 }

583

584 static int h264_parse(AVCodecParserContext *s,

585 AVCodecContext *avctx,

586 const uint8_t **poutbuf, int *poutbuf_size,

587 const uint8_t *buf, int buf_size)

588 {

589 H264ParseContext *p = s->priv_data;

590 ParseContext *pc = &p->pc;

591 AVRational time_base = { 0, 1 };

592 int next;

593

594 if (!p->got_first) {

595 p->got_first = 1;

596 if (avctx->extradata_size) {

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

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

599 avctx->err_recognition, avctx);

600 }

601 }

602

603 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

604 next = buf_size;

605 } else {

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

607

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

609 *poutbuf = NULL;

610 *poutbuf_size = 0;

611 return buf_size;

612 }

613

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

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

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

617 }

618 }

619

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

621

622 if (avctx->framerate.num)

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

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

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

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

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

628 } else {

629 s->dts_sync_point = INT_MIN;

630 s->dts_ref_dts_delta = INT_MIN;

631 s->pts_dts_delta = INT_MIN;

632 }

633

634 if (s->flags & PARSER_FLAG_ONCE) {

635 s->flags &= PARSER_FLAG_COMPLETE_FRAMES;

636 }

637

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

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

640 if (den > 0) {

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

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

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

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

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

646 // compute DTS based on reference timestamp

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

648 }

649

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

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

652

653 if (s->dts_sync_point > 0)

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

655 }

656 }

657

658 *poutbuf = buf;

659 *poutbuf_size = buf_size;

660 return next;

661 }

662

663 static void h264_close(AVCodecParserContext *s)

664 {

665 H264ParseContext *p = s->priv_data;

666 ParseContext *pc = &p->pc;

667

668 av_freep(&pc->buffer);

669

670 ff_h264_sei_uninit(&p->sei);

671 ff_h264_ps_uninit(&p->ps);

672 }

673

674 static av_cold int init(AVCodecParserContext *s)

675 {

676 H264ParseContext *p = s->priv_data;

677

678 p->reference_dts = AV_NOPTS_VALUE;

679 p->last_frame_num = INT_MAX;

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

681 return 0;

682 }

683

684 const AVCodecParser ff_h264_parser = {

685 .codec_ids = { AV_CODEC_ID_H264 },

686 .priv_data_size = sizeof(H264ParseContext),

687 .parser_init = init,

688 .parser_parse = h264_parse,

689 .parser_close = h264_close,

690 };

MMCO_LONG2UNUSED

@ MMCO_LONG2UNUSED

Definition: h264_parse.h:62

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:33

H264SEIPictureTiming::pic_struct

H264_SEI_PicStructType pic_struct

Definition: h264_sei.h:60

H264ParseContext

Definition: h264_parser.c:53

MMCO_LONG

@ MMCO_LONG

Definition: h264_parse.h:66

H264ParamSets::sps

const SPS * sps

ordinary pointer, no RefStruct reference

Definition: h264_ps.h:150

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

H264POCContext::frame_num_offset

int frame_num_offset

for POC type 2

Definition: h264_parse.h:90

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

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:58

ff_h264_ps_uninit

void ff_h264_ps_uninit(H264ParamSets *ps)

Uninit H264 param sets structure.

Definition: h264_ps.c:270

H264POCContext::delta_poc_bottom

int delta_poc_bottom

Definition: h264_parse.h:85

H264ParseContext::parse_last_mb

int parse_last_mb

Definition: h264_parser.c:65

AV_FIELD_PROGRESSIVE

@ AV_FIELD_PROGRESSIVE

Definition: defs.h:202

AV_PICTURE_STRUCTURE_UNKNOWN

@ AV_PICTURE_STRUCTURE_UNKNOWN

unknown

Definition: avcodec.h:2742

AVCodecContext::err_recognition

int err_recognition

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

Definition: avcodec.h:1430

H264_MAX_MMCO_COUNT

@ H264_MAX_MMCO_COUNT

Definition: h264.h:92

int64_t

long long int64_t

Definition: coverity.c:34

H264ParseContext::is_avc

int is_avc

Definition: h264_parser.c:59

H264SEIRecoveryPoint::recovery_frame_cnt

int recovery_frame_cnt

recovery_frame_cnt

Definition: h264_sei.h:98

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

H264ParamSets::pps_list

const PPS * pps_list[MAX_PPS_COUNT]

RefStruct references.

Definition: h264_ps.h:146

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:171

h264_parse.h

H264_NAL_SLICE

@ H264_NAL_SLICE

Definition: h264.h:35

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:63

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:478

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:32

H264_NAL_SEI

@ H264_NAL_SEI

Definition: h264.h:40

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:62

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:514

ParseContext::last_index

int last_index

Definition: parser.h:31

H264POCContext::prev_poc_lsb

int prev_poc_lsb

poc_lsb of the last reference pic for POC type 0

Definition: h264_parse.h:89

H264ParseContext::got_first

int got_first

Definition: h264_parser.c:61

H264POCContext::delta_poc

int delta_poc[2]

Definition: h264_parse.h:86

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

H264_NAL_DPA

@ H264_NAL_DPA

Definition: h264.h:36

MMCO_SET_MAX_LONG

@ MMCO_SET_MAX_LONG

Definition: h264_parse.h:64

H264_NAL_PPS

@ H264_NAL_PPS

Definition: h264.h:42

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:566

golomb.h

exp golomb vlc stuff

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

AV_FIELD_TT

@ AV_FIELD_TT

Top coded_first, top displayed first.

Definition: defs.h:203

ParseContext

Definition: parser.h:28

H264POCContext::prev_frame_num

int prev_frame_num

frame_num of the last pic for POC type 1/2

Definition: h264_parse.h:92

H264ParseContext::h264dsp

H264DSPContext h264dsp

Definition: h264_parser.c:56

PPS::redundant_pic_cnt_present

int redundant_pic_cnt_present

redundant_pic_cnt_present_flag

Definition: h264_ps.h:125

fail

#define fail()

Definition: checkasm.h:188

PPS::weighted_bipred_idc

int weighted_bipred_idc

Definition: h264_ps.h:119

ff_h264_sei_decode

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

Definition: h264_sei.c:230

GetBitContext

Definition: get_bits.h:108

AV_PIX_FMT_YUV422P9

#define AV_PIX_FMT_YUV422P9

Definition: pixfmt.h:476

h264_close

static void h264_close(AVCodecParserContext *s)

Definition: h264_parser.c:663

H264SEIPictureTiming::present

int present

Definition: h264_sei.h:59

PPS::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264_ps.h:117

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:257

refstruct.h

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:584

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:481

ParseContext::buffer

uint8_t * buffer

Definition: parser.h:29

AV_PICTURE_STRUCTURE_FRAME

@ AV_PICTURE_STRUCTURE_FRAME

coded as frame

Definition: avcodec.h:2745

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:545

AV_FIELD_UNKNOWN

@ AV_FIELD_UNKNOWN

Definition: defs.h:201

H2645NAL::size

int size

Definition: h2645_parse.h:36

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

H2645SEIFramePacking::arrangement_cancel_flag

int arrangement_cancel_flag

is previous arrangement canceled, -1 if never received (currently H.264 only)

Definition: h2645_sei.h:66

#define s(width, name)

Definition: cbs_vp9.c:198

H264POCContext::prev_frame_num_offset

int prev_frame_num_offset

for POC type 2

Definition: h264_parse.h:91

H264SEIBufferingPeriod::present

int present

Buffering period SEI flag.

Definition: h264_sei.h:102

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:475

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

SPS::ref_frame_count

int ref_frame_count

num_ref_frames

Definition: h264_ps.h:57

if(ret)

Definition: filter_design.txt:179

AV_PICTURE_STRUCTURE_BOTTOM_FIELD

@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD

coded as bottom field

Definition: avcodec.h:2744

H264DSPContext::startcode_find_candidate

int(* startcode_find_candidate)(const uint8_t *buf, int size)

Search buf from the start for up to size bytes.

Definition: h264dsp.h:117

NULL

#define NULL

Definition: coverity.c:32

PPS::pic_order_present

int pic_order_present

bottom_field_pic_order_in_frame_present_flag

Definition: h264_ps.h:114

H264SEIPictureTiming::dpb_output_delay

int dpb_output_delay

dpb_output_delay in picture timing SEI message, see H.264 C.2.2

Definition: h264_sei.h:72

H264SEIContext::recovery_point

H264SEIRecoveryPoint recovery_point

Definition: h264_sei.h:122

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:2743

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

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:479

H264_NAL_IDR_SLICE

@ H264_NAL_IDR_SLICE

Definition: h264.h:39

AVCodecContext::level

int level

Encoding level descriptor.

Definition: avcodec.h:1794

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:80

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_AUD

@ H264_NAL_AUD

Definition: h264.h:43

H2645SEI::frame_packing

H2645SEIFramePacking frame_packing

Definition: h2645_sei.h:135

AVCodecParser::codec_ids

int codec_ids[7]

Definition: avcodec.h:2908

AVCodecContext::pkt_timebase

AVRational pkt_timebase

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

Definition: avcodec.h:557

PPS::weighted_pred

int weighted_pred

weighted_pred_flag

Definition: h264_ps.h:118

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

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:64

ff_h264_parser

const AVCodecParser ff_h264_parser

Definition: h264_parser.c:684

H264ParseContext::last_frame_num

int last_frame_num

Definition: h264_parser.c:67

#define mb

Definition: vf_colormatrix.c:99

H264POCContext::frame_num

int frame_num

Definition: h264_parse.h:87

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:203

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:2782

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

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

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:36

H264POCContext

Definition: h264_parse.h:82

AV_FIELD_BB

@ AV_FIELD_BB

Bottom coded first, bottom displayed first.

Definition: defs.h:204

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:56

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:52

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

H2645SEIUnregistered::x264_build

int x264_build

Definition: h2645_sei.h:60

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

H264SEIContext::buffering_period

H264SEIBufferingPeriod buffering_period

Definition: h264_sei.h:123

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:67

AV_PIX_FMT_YUV444P9

#define AV_PIX_FMT_YUV444P9

Definition: pixfmt.h:477

H2645RBSP::rbsp_buffer_alloc_size

int rbsp_buffer_alloc_size

Definition: h2645_parse.h:77

avcodec.h

H264SEIContext::common

H2645SEI common

Definition: h264_sei.h:120

AVCodecParserContext

Definition: avcodec.h:2748

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

PPS::sps

const SPS * sps

RefStruct reference.

Definition: h264_ps.h:141

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

sps

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

Definition: cbs_h264_syntax_template.c:260

ff_refstruct_replace

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

Ensure *dstp refers to the same object as src.

Definition: refstruct.c:160

av_sat_add64

#define av_sat_add64

Definition: common.h:139

#define U(x)

Definition: vpx_arith.h:37

H2645SEI::unregistered

H2645SEIUnregistered unregistered

Definition: h2645_sei.h:134

AVCodecContext

main external API structure.

Definition: avcodec.h:451

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:70

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:281

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:60

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1650

H264ParamSets

Definition: h264_ps.h:144

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:280

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:674

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

H264POCContext::poc_lsb

int poc_lsb

Definition: h264_parse.h:83

H264ParseContext::ps

H264ParamSets ps

Definition: h264_parser.c:55

H264ParseContext::poc

H264POCContext poc

Definition: h264_parser.c:57

END_NOT_FOUND

#define END_NOT_FOUND

Definition: parser.h:40

state

static struct @454 state

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AVCodecParser

Definition: avcodec.h:2907

H264SEIPictureTiming::cpb_removal_delay

int cpb_removal_delay

cpb_removal_delay in picture timing SEI message, see H.264 C.1.2

Definition: h264_sei.h:77

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:66

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

H264POCContext::poc_msb

int poc_msb

Definition: h264_parse.h:84

H264ParamSets::pps

const PPS * pps

RefStruct reference.

Definition: h264_ps.h:149

PARSER_FLAG_ONCE

#define PARSER_FLAG_ONCE

Definition: avcodec.h:2783

H264POCContext::prev_poc_msb

int prev_poc_msb

poc_msb of the last reference pic for POC type 0

Definition: h264_parse.h:88

H2645RBSP

Definition: h2645_parse.h:74

H264_SEI_PIC_STRUCT_TOP_FIELD

@ H264_SEI_PIC_STRUCT_TOP_FIELD

1: top field

Definition: h264_sei.h:33

H264_NAL_SPS

@ H264_NAL_SPS

Definition: h264.h:41

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:54

H264SEIContext::picture_timing

H264SEIPictureTiming picture_timing

Definition: h264_sei.h:121

Generated on Fri Aug 22 2025 13:58:22 for FFmpeg by doxygen 1.8.17