1/* 2 * H.26L/H.264/AVC/JVT/14496-10/... parser 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> 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 */ 21 22/** 23 * @file 24 * H.264 / AVC / MPEG-4 part10 parser. 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#define UNCHECKED_BITSTREAM_READER 1 29 30#include <stdint.h> 31 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" 37 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 "startcode.h" 51 52typedef struct H264ParseContext { 53 ParseContext pc; 54 H264ParamSets ps; 55 H264DSPContext h264dsp; 56 H264POCContext poc; 57 H264SEIContext sei; 58 int is_avc; 59 int nal_length_size; 60 int got_first; 61 int picture_structure; 62 uint8_t parse_history[6]; 63 int parse_history_count; 64 int parse_last_mb; 65 int64_t reference_dts; 66 int last_frame_num, last_picture_structure; 67} H264ParseContext; 68 69static int find_start_code(const uint8_t *buf, int buf_size, 70 int buf_index, int next_avc) 71{ 72 uint32_t state = -1; 73 74 buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1; 75 76 return FFMIN(buf_index, buf_size); 77} 78 79static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf, 80 int buf_size, void *logctx) 81{ 82 int i, j; 83 uint32_t state; 84 ParseContext *pc = &p->pc; 85 86 int next_avc = p->is_avc ? 0 : buf_size; 87// mb_addr= pc->mb_addr - 1; 88 state = pc->state; 89 if (state > 13) 90 state = 7; 91 92 if (p->is_avc && !p->nal_length_size) 93 av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n"); 94 95 for (i = 0; i < buf_size; i++) { 96 if (i >= next_avc) { 97 int64_t nalsize = 0; 98 i = next_avc; 99 for (j = 0; j < p->nal_length_size; j++) 100 nalsize = (nalsize << 8) | buf[i++]; 101 if (!nalsize || nalsize > buf_size - i) { 102 av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %"PRId64" " 103 "remaining %d\n", nalsize, buf_size - i); 104 return buf_size; 105 } 106 next_avc = i + nalsize; 107 state = 5; 108 } 109 110 if (state == 7) { 111 i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i); 112 if (i < next_avc) 113 state = 2; 114 } else if (state <= 2) { 115 if (buf[i] == 1) 116 state ^= 5; // 2->7, 1->4, 0->5 117 else if (buf[i]) 118 state = 7; 119 else 120 state >>= 1; // 2->1, 1->0, 0->0 121 } else if (state <= 5) { 122 int nalu_type = buf[i] & 0x1F; 123 if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS || 124 nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) { 125 if (pc->frame_start_found) { 126 i++; 127 goto found; 128 } 129 } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA || 130 nalu_type == H264_NAL_IDR_SLICE) { 131 state += 8; 132 continue; 133 } 134 state = 7; 135 } else { 136 unsigned int mb, last_mb = p->parse_last_mb; 137 GetBitContext gb; 138 p->parse_history[p->parse_history_count++] = buf[i]; 139 140 init_get_bits(&gb, p->parse_history, 8*p->parse_history_count); 141 mb= get_ue_golomb_long(&gb); 142 if (get_bits_left(&gb) > 0 || p->parse_history_count > 5) { 143 p->parse_last_mb = mb; 144 if (pc->frame_start_found) { 145 if (mb <= last_mb) { 146 i -= p->parse_history_count - 1; 147 p->parse_history_count = 0; 148 goto found; 149 } 150 } else 151 pc->frame_start_found = 1; 152 p->parse_history_count = 0; 153 state = 7; 154 } 155 } 156 } 157 pc->state = state; 158 if (p->is_avc) 159 return next_avc; 160 return END_NOT_FOUND; 161 162found: 163 pc->state = 7; 164 pc->frame_start_found = 0; 165 if (p->is_avc) 166 return next_avc; 167 return i - (state & 5); 168} 169 170static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, 171 void *logctx) 172{ 173 H264PredWeightTable pwt; 174 int slice_type_nos = s->pict_type & 3; 175 H264ParseContext *p = s->priv_data; 176 int list_count, ref_count[2]; 177 178 179 if (p->ps.pps->redundant_pic_cnt_present) 180 get_ue_golomb(gb); // redundant_pic_count 181 182 if (slice_type_nos == AV_PICTURE_TYPE_B) 183 get_bits1(gb); // direct_spatial_mv_pred 184 185 if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps, 186 slice_type_nos, p->picture_structure, logctx) < 0) 187 return AVERROR_INVALIDDATA; 188 189 if (slice_type_nos != AV_PICTURE_TYPE_I) { 190 int list; 191 for (list = 0; list < list_count; list++) { 192 if (get_bits1(gb)) { 193 int index; 194 for (index = 0; ; index++) { 195 unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb); 196 197 if (reordering_of_pic_nums_idc < 3) 198 get_ue_golomb_long(gb); 199 else if (reordering_of_pic_nums_idc > 3) { 200 av_log(logctx, AV_LOG_ERROR, 201 "illegal reordering_of_pic_nums_idc %d\n", 202 reordering_of_pic_nums_idc); 203 return AVERROR_INVALIDDATA; 204 } else 205 break; 206 207 if (index >= ref_count[list]) { 208 av_log(logctx, AV_LOG_ERROR, 209 "reference count %d overflow\n", index); 210 return AVERROR_INVALIDDATA; 211 } 212 } 213 } 214 } 215 } 216 217 if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) || 218 (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B)) 219 ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos, 220 &pwt, p->picture_structure, logctx); 221 222 if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag 223 int i; 224 for (i = 0; i < H264_MAX_MMCO_COUNT; i++) { 225 MMCOOpcode opcode = get_ue_golomb_31(gb); 226 if (opcode > (unsigned) MMCO_LONG) { 227 av_log(logctx, AV_LOG_ERROR, 228 "illegal memory management control operation %d\n", 229 opcode); 230 return AVERROR_INVALIDDATA; 231 } 232 if (opcode == MMCO_END) 233 return 0; 234 else if (opcode == MMCO_RESET) 235 return 1; 236 237 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) 238 get_ue_golomb_long(gb); // difference_of_pic_nums_minus1 239 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED || 240 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) 241 get_ue_golomb_31(gb); 242 } 243 } 244 245 return 0; 246} 247 248/** 249 * Parse NAL units of found picture and decode some basic information. 250 * 251 * @param s parser context. 252 * @param avctx codec context. 253 * @param buf buffer with field/frame data. 254 * @param buf_size size of the buffer. 255 */ 256static inline int parse_nal_units(AVCodecParserContext *s, 257 AVCodecContext *avctx, 258 const uint8_t * const buf, int buf_size) 259{ 260 H264ParseContext *p = s->priv_data; 261 H2645RBSP rbsp = { NULL }; 262 H2645NAL nal = { NULL }; 263 int buf_index, next_avc; 264 unsigned int pps_id; 265 unsigned int slice_type; 266 int state = -1, got_reset = 0; 267 int q264 = buf_size >=4 && !memcmp("Q264", buf, 4); 268 int field_poc[2]; 269 int ret; 270 271 /* set some sane default values */ 272 s->pict_type = AV_PICTURE_TYPE_I; 273 s->key_frame = 0; 274 s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN; 275 276 ff_h264_sei_uninit(&p->sei); 277 p->sei.frame_packing.arrangement_cancel_flag = -1; 278 p->sei.unregistered.x264_build = -1; 279 280 if (!buf_size) 281 return 0; 282 283 av_fast_padded_malloc(&rbsp.rbsp_buffer, &rbsp.rbsp_buffer_alloc_size, buf_size); 284 if (!rbsp.rbsp_buffer) 285 return AVERROR(ENOMEM); 286 287 buf_index = 0; 288 next_avc = p->is_avc ? 0 : buf_size; 289 for (;;) { 290 const SPS *sps; 291 int src_length, consumed, nalsize = 0; 292 293 if (buf_index >= next_avc) { 294 nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx); 295 if (nalsize < 0) 296 break; 297 next_avc = buf_index + nalsize; 298 } else { 299 buf_index = find_start_code(buf, buf_size, buf_index, next_avc); 300 if (buf_index >= buf_size) 301 break; 302 if (buf_index >= next_avc) 303 continue; 304 } 305 src_length = next_avc - buf_index; 306 307 state = buf[buf_index]; 308 switch (state & 0x1f) { 309 case H264_NAL_SLICE: 310 case H264_NAL_IDR_SLICE: 311 // Do not walk the whole buffer just to decode slice header 312 if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) { 313 /* IDR or disposable slice 314 * No need to decode many bytes because MMCOs shall not be present. */ 315 if (src_length > 60) 316 src_length = 60; 317 } else { 318 /* To decode up to MMCOs */ 319 if (src_length > 1000) 320 src_length = 1000; 321 } 322 break; 323 } 324 consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1); 325 if (consumed < 0) 326 break; 327 328 buf_index += consumed; 329 330 ret = init_get_bits8(&nal.gb, nal.data, nal.size); 331 if (ret < 0) 332 goto fail; 333 get_bits1(&nal.gb); 334 nal.ref_idc = get_bits(&nal.gb, 2); 335 nal.type = get_bits(&nal.gb, 5); 336 337 switch (nal.type) { 338 case H264_NAL_SPS: 339 ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0); 340 break; 341 case H264_NAL_PPS: 342 ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps, 343 nal.size_bits); 344 break; 345 case H264_NAL_SEI: 346 ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx); 347 break; 348 case H264_NAL_IDR_SLICE: 349 s->key_frame = 1; 350 351 p->poc.prev_frame_num = 0; 352 p->poc.prev_frame_num_offset = 0; 353 p->poc.prev_poc_msb = 354 p->poc.prev_poc_lsb = 0; 355 /* fall through */ 356 case H264_NAL_SLICE: 357 get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice 358 slice_type = get_ue_golomb_31(&nal.gb); 359 s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5]; 360 if (p->sei.recovery_point.recovery_frame_cnt >= 0) { 361 /* key frame, since recovery_frame_cnt is set */ 362 s->key_frame = 1; 363 } 364 pps_id = get_ue_golomb(&nal.gb); 365 if (pps_id >= MAX_PPS_COUNT) { 366 av_log(avctx, AV_LOG_ERROR, 367 "pps_id %u out of range\n", pps_id); 368 goto fail; 369 } 370 if (!p->ps.pps_list[pps_id]) { 371 av_log(avctx, AV_LOG_ERROR, 372 "non-existing PPS %u referenced\n", pps_id); 373 goto fail; 374 } 375 376 av_buffer_unref(&p->ps.pps_ref); 377 p->ps.pps = NULL; 378 p->ps.sps = NULL; 379 p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]); 380 if (!p->ps.pps_ref) 381 goto fail; 382 p->ps.pps = (const PPS*)p->ps.pps_ref->data; 383 p->ps.sps = p->ps.pps->sps; 384 sps = p->ps.sps; 385 386 // heuristic to detect non marked keyframes 387 if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I) 388 s->key_frame = 1; 389 390 p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num); 391 392 s->coded_width = 16 * sps->mb_width; 393 s->coded_height = 16 * sps->mb_height; 394 s->width = s->coded_width - (sps->crop_right + sps->crop_left); 395 s->height = s->coded_height - (sps->crop_top + sps->crop_bottom); 396 if (s->width <= 0 || s->height <= 0) { 397 s->width = s->coded_width; 398 s->height = s->coded_height; 399 } 400 401 switch (sps->bit_depth_luma) { 402 case 9: 403 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9; 404 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9; 405 else s->format = AV_PIX_FMT_YUV420P9; 406 break; 407 case 10: 408 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10; 409 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10; 410 else s->format = AV_PIX_FMT_YUV420P10; 411 break; 412 case 8: 413 if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P; 414 else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P; 415 else s->format = AV_PIX_FMT_YUV420P; 416 break; 417 default: 418 s->format = AV_PIX_FMT_NONE; 419 } 420 421 avctx->profile = ff_h264_get_profile(sps); 422 avctx->level = sps->level_idc; 423 424 if (sps->frame_mbs_only_flag) { 425 p->picture_structure = PICT_FRAME; 426 } else { 427 if (get_bits1(&nal.gb)) { // field_pic_flag 428 p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag 429 } else { 430 p->picture_structure = PICT_FRAME; 431 } 432 } 433 434 if (nal.type == H264_NAL_IDR_SLICE) 435 get_ue_golomb_long(&nal.gb); /* idr_pic_id */ 436 if (sps->poc_type == 0) { 437 p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb); 438 439 if (p->ps.pps->pic_order_present == 1 && 440 p->picture_structure == PICT_FRAME) 441 p->poc.delta_poc_bottom = get_se_golomb(&nal.gb); 442 } 443 444 if (sps->poc_type == 1 && 445 !sps->delta_pic_order_always_zero_flag) { 446 p->poc.delta_poc[0] = get_se_golomb(&nal.gb); 447 448 if (p->ps.pps->pic_order_present == 1 && 449 p->picture_structure == PICT_FRAME) 450 p->poc.delta_poc[1] = get_se_golomb(&nal.gb); 451 } 452 453 /* Decode POC of this picture. 454 * The prev_ values needed for decoding POC of the next picture are not set here. */ 455 field_poc[0] = field_poc[1] = INT_MAX; 456 ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps, 457 &p->poc, p->picture_structure, nal.ref_idc); 458 if (ret < 0) 459 goto fail; 460 461 /* Continue parsing to check if MMCO_RESET is present. 462 * FIXME: MMCO_RESET could appear in non-first slice. 463 * Maybe, we should parse all undisposable non-IDR slice of this 464 * picture until encountering MMCO_RESET in a slice of it. */ 465 if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) { 466 got_reset = scan_mmco_reset(s, &nal.gb, avctx); 467 if (got_reset < 0) 468 goto fail; 469 } 470 471 /* Set up the prev_ values for decoding POC of the next picture. */ 472 p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num; 473 p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset; 474 if (nal.ref_idc != 0) { 475 if (!got_reset) { 476 p->poc.prev_poc_msb = p->poc.poc_msb; 477 p->poc.prev_poc_lsb = p->poc.poc_lsb; 478 } else { 479 p->poc.prev_poc_msb = 0; 480 p->poc.prev_poc_lsb = 481 p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0]; 482 } 483 } 484 485 if (p->sei.picture_timing.present) { 486 ret = ff_h264_sei_process_picture_timing(&p->sei.picture_timing, 487 sps, avctx); 488 if (ret < 0) { 489 av_log(avctx, AV_LOG_ERROR, "Error processing the picture timing SEI\n"); 490 p->sei.picture_timing.present = 0; 491 } 492 } 493 494 if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { 495 switch (p->sei.picture_timing.pic_struct) { 496 case H264_SEI_PIC_STRUCT_TOP_FIELD: 497 case H264_SEI_PIC_STRUCT_BOTTOM_FIELD: 498 s->repeat_pict = 0; 499 break; 500 case H264_SEI_PIC_STRUCT_FRAME: 501 case H264_SEI_PIC_STRUCT_TOP_BOTTOM: 502 case H264_SEI_PIC_STRUCT_BOTTOM_TOP: 503 s->repeat_pict = 1; 504 break; 505 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP: 506 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: 507 s->repeat_pict = 2; 508 break; 509 case H264_SEI_PIC_STRUCT_FRAME_DOUBLING: 510 s->repeat_pict = 3; 511 break; 512 case H264_SEI_PIC_STRUCT_FRAME_TRIPLING: 513 s->repeat_pict = 5; 514 break; 515 default: 516 s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; 517 break; 518 } 519 } else { 520 s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; 521 } 522 523 if (p->picture_structure == PICT_FRAME) { 524 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME; 525 if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { 526 switch (p->sei.picture_timing.pic_struct) { 527 case H264_SEI_PIC_STRUCT_TOP_BOTTOM: 528 case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP: 529 s->field_order = AV_FIELD_TT; 530 break; 531 case H264_SEI_PIC_STRUCT_BOTTOM_TOP: 532 case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: 533 s->field_order = AV_FIELD_BB; 534 break; 535 default: 536 s->field_order = AV_FIELD_PROGRESSIVE; 537 break; 538 } 539 } else { 540 if (field_poc[0] < field_poc[1]) 541 s->field_order = AV_FIELD_TT; 542 else if (field_poc[0] > field_poc[1]) 543 s->field_order = AV_FIELD_BB; 544 else 545 s->field_order = AV_FIELD_PROGRESSIVE; 546 } 547 } else { 548 if (p->picture_structure == PICT_TOP_FIELD) 549 s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD; 550 else 551 s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD; 552 if (p->poc.frame_num == p->last_frame_num && 553 p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN && 554 p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME && 555 p->last_picture_structure != s->picture_structure) { 556 if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD) 557 s->field_order = AV_FIELD_TT; 558 else 559 s->field_order = AV_FIELD_BB; 560 } else { 561 s->field_order = AV_FIELD_UNKNOWN; 562 } 563 p->last_picture_structure = s->picture_structure; 564 p->last_frame_num = p->poc.frame_num; 565 } 566 if (sps->timing_info_present_flag) { 567 int64_t den = sps->time_scale; 568 if (p->sei.unregistered.x264_build < 44U) 569 den *= 2; 570 av_reduce(&avctx->framerate.den, &avctx->framerate.num, 571 sps->num_units_in_tick * avctx->ticks_per_frame, den, 1 << 30); 572 } 573 574 av_freep(&rbsp.rbsp_buffer); 575 return 0; /* no need to evaluate the rest */ 576 } 577 } 578 if (q264) { 579 av_freep(&rbsp.rbsp_buffer); 580 return 0; 581 } 582 /* didn't find a picture! */ 583 av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size); 584fail: 585 av_freep(&rbsp.rbsp_buffer); 586 return -1; 587} 588 589static int h264_parse(AVCodecParserContext *s, 590 AVCodecContext *avctx, 591 const uint8_t **poutbuf, int *poutbuf_size, 592 const uint8_t *buf, int buf_size) 593{ 594 H264ParseContext *p = s->priv_data; 595 ParseContext *pc = &p->pc; 596 int next; 597 598 if (!p->got_first) { 599 p->got_first = 1; 600 if (avctx->extradata_size) { 601 ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, 602 &p->ps, &p->is_avc, &p->nal_length_size, 603 avctx->err_recognition, avctx); 604 } 605 } 606 607 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { 608 next = buf_size; 609 } else { 610 next = h264_find_frame_end(p, buf, buf_size, avctx); 611 612 if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { 613 *poutbuf = NULL; 614 *poutbuf_size = 0; 615 return buf_size; 616 } 617 618 if (next < 0 && next != END_NOT_FOUND) { 619 av_assert1(pc->last_index + next >= 0); 620 h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state 621 } 622 } 623 624 parse_nal_units(s, avctx, buf, buf_size); 625 626 if (avctx->framerate.num) 627 avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1})); 628 if (p->sei.picture_timing.cpb_removal_delay >= 0) { 629 s->dts_sync_point = p->sei.buffering_period.present; 630 s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay; 631 s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay; 632 } else { 633 s->dts_sync_point = INT_MIN; 634 s->dts_ref_dts_delta = INT_MIN; 635 s->pts_dts_delta = INT_MIN; 636 } 637 638 if (s->flags & PARSER_FLAG_ONCE) { 639 s->flags &= PARSER_FLAG_COMPLETE_FRAMES; 640 } 641 642 if (s->dts_sync_point >= 0) { 643 int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num; 644 if (den > 0) { 645 int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den; 646 if (s->dts != AV_NOPTS_VALUE) { 647 // got DTS from the stream, update reference timestamp 648 p->reference_dts = av_sat_sub64(s->dts, av_rescale(s->dts_ref_dts_delta, num, den)); 649 } else if (p->reference_dts != AV_NOPTS_VALUE) { 650 // compute DTS based on reference timestamp 651 s->dts = av_sat_add64(p->reference_dts, av_rescale(s->dts_ref_dts_delta, num, den)); 652 } 653 654 if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE) 655 s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den); 656 657 if (s->dts_sync_point > 0) 658 p->reference_dts = s->dts; // new reference 659 } 660 } 661 662 *poutbuf = buf; 663 *poutbuf_size = buf_size; 664 return next; 665} 666 667static void h264_close(AVCodecParserContext *s) 668{ 669 H264ParseContext *p = s->priv_data; 670 ParseContext *pc = &p->pc; 671 672 av_freep(&pc->buffer); 673 674 ff_h264_sei_uninit(&p->sei); 675 ff_h264_ps_uninit(&p->ps); 676} 677 678static av_cold int init(AVCodecParserContext *s) 679{ 680 H264ParseContext *p = s->priv_data; 681 682 p->reference_dts = AV_NOPTS_VALUE; 683 p->last_frame_num = INT_MAX; 684 ff_h264dsp_init(&p->h264dsp, 8, 1); 685 return 0; 686} 687 688const AVCodecParser ff_h264_parser = { 689 .codec_ids = { AV_CODEC_ID_H264 }, 690 .priv_data_size = sizeof(H264ParseContext), 691 .parser_init = init, 692 .parser_parse = h264_parse, 693 .parser_close = h264_close, 694}; 695