falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82098 Commits
32 Branches
293MB
Tree: f271a9bd99
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f271a9bd99'
${ noResults }
FFmpeg/libavcodec/h264_parser.c

706 lines
25KB
Raw Blame History 

  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 <assert.h>

  31. #include <stdint.h>

  32. 

  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"

  38. 

  39. #include "avcodec.h"

  40. #include "get_bits.h"

  41. #include "golomb.h"

  42. #include "h264.h"

  43. #include "h264_sei.h"

  44. #include "h264_ps.h"

  45. #include "h264data.h"

  46. #include "internal.h"

  47. #include "mpegutils.h"

  48. #include "parser.h"

  49. 

  50. typedef struct H264ParseContext {

  51.     ParseContext pc;

  52.     H264ParamSets ps;

  53.     H264DSPContext h264dsp;

  54.     H264POCContext poc;

  55.     H264SEIContext sei;

  56.     int is_avc;

  57.     int nal_length_size;

  58.     int got_first;

  59.     int picture_structure;

  60.     uint8_t parse_history[6];

  61.     int parse_history_count;

  62.     int parse_last_mb;

  63.     int64_t reference_dts;

  64.     int last_frame_num, last_picture_structure;

  65. } H264ParseContext;

  66. 

  67. 

  68. static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,

  69.                                int buf_size, void *logctx)

  70. {

  71.     int i, j;

  72.     uint32_t state;

  73.     ParseContext *pc = &p->pc;

  74. 

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

  76. //    mb_addr= pc->mb_addr - 1;

  77.     state = pc->state;

  78.     if (state > 13)

  79.         state = 7;

  80. 

  81.     if (p->is_avc && !p->nal_length_size)

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

  83. 

  84.     for (i = 0; i < buf_size; i++) {

  85.         if (i >= next_avc) {

  86.             int nalsize = 0;

  87.             i = next_avc;

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

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

  90.             if (nalsize <= 0 || nalsize > buf_size - i) {

  91.                 av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i);

  92.                 return buf_size;

  93.             }

  94.             next_avc = i + nalsize;

  95.             state    = 5;

  96.         }

  97. 

  98.         if (state == 7) {

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

  100.             if (i < next_avc)

  101.                 state = 2;

  102.         } else if (state <= 2) {

  103.             if (buf[i] == 1)

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

  105.             else if (buf[i])

  106.                 state = 7;

  107.             else

  108.                 state >>= 1;           // 2->1, 1->0, 0->0

  109.         } else if (state <= 5) {

  110.             int nalu_type = buf[i] & 0x1F;

  111.             if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||

  112.                 nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {

  113.                 if (pc->frame_start_found) {

  114.                     i++;

  115.                     goto found;

  116.                 }

  117.             } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||

  118.                        nalu_type == H264_NAL_IDR_SLICE) {

  119.                 state += 8;

  120.                 continue;

  121.             }

  122.             state = 7;

  123.         } else {

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

  125.             if (p->parse_history_count > 5) {

  126.                 unsigned int mb, last_mb = p->parse_last_mb;

  127.                 GetBitContext gb;

  128. 

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

  130.                 p->parse_history_count = 0;

  131.                 mb= get_ue_golomb_long(&gb);

  132.                 p->parse_last_mb = mb;

  133.                 if (pc->frame_start_found) {

  134.                     if (mb <= last_mb)

  135.                         goto found;

  136.                 } else

  137.                     pc->frame_start_found = 1;

  138.                 state = 7;

  139.             }

  140.         }

  141.     }

  142.     pc->state = state;

  143.     if (p->is_avc)

  144.         return next_avc;

  145.     return END_NOT_FOUND;

  146. 

  147. found:

  148.     pc->state             = 7;

  149.     pc->frame_start_found = 0;

  150.     if (p->is_avc)

  151.         return next_avc;

  152.     return i - (state & 5) - 5 * (state > 7);

  153. }

  154. 

  155. static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,

  156.                            void *logctx)

  157. {

  158.     H264PredWeightTable pwt;

  159.     int slice_type_nos = s->pict_type & 3;

  160.     H264ParseContext *p = s->priv_data;

  161.     int list_count, ref_count[2];

  162. 

  163. 

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

  165.         get_ue_golomb(gb); // redundant_pic_count

  166. 

  167.     if (slice_type_nos == AV_PICTURE_TYPE_B)

  168.         get_bits1(gb); // direct_spatial_mv_pred

  169. 

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

  171.                                 slice_type_nos, p->picture_structure, logctx) < 0)

  172.         return AVERROR_INVALIDDATA;

  173. 

  174.     if (slice_type_nos != AV_PICTURE_TYPE_I) {

  175.         int list;

  176.         for (list = 0; list < list_count; list++) {

  177.             if (get_bits1(gb)) {

  178.                 int index;

  179.                 for (index = 0; ; index++) {

  180.                     unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);

  181. 

  182.                     if (reordering_of_pic_nums_idc < 3)

  183.                         get_ue_golomb_long(gb);

  184.                     else if (reordering_of_pic_nums_idc > 3) {

  185.                         av_log(logctx, AV_LOG_ERROR,

  186.                                "illegal reordering_of_pic_nums_idc %d\n",

  187.                                reordering_of_pic_nums_idc);

  188.                         return AVERROR_INVALIDDATA;

  189.                     } else

  190.                         break;

  191. 

  192.                     if (index >= ref_count[list]) {

  193.                         av_log(logctx, AV_LOG_ERROR,

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

  195.                         return AVERROR_INVALIDDATA;

  196.                     }

  197.                 }

  198.             }

  199.         }

  200.     }

  201. 

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

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

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

  205.                                   &pwt, logctx);

  206. 

  207.     if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag

  208.         int i;

  209.         for (i = 0; i < MAX_MMCO_COUNT; i++) {

  210.             MMCOOpcode opcode = get_ue_golomb_31(gb);

  211.             if (opcode > (unsigned) MMCO_LONG) {

  212.                 av_log(logctx, AV_LOG_ERROR,

  213.                        "illegal memory management control operation %d\n",

  214.                        opcode);

  215.                 return AVERROR_INVALIDDATA;

  216.             }

  217.             if (opcode == MMCO_END)

  218.                return 0;

  219.             else if (opcode == MMCO_RESET)

  220.                 return 1;

  221. 

  222.             if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)

  223.                 get_ue_golomb_long(gb); // difference_of_pic_nums_minus1

  224.             if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||

  225.                 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)

  226.                 get_ue_golomb_31(gb);

  227.         }

  228.     }

  229. 

  230.     return 0;

  231. }

  232. 

  233. /**

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

  235.  *

  236.  * @param s parser context.

  237.  * @param avctx codec context.

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

  239.  * @param buf_size size of the buffer.

  240.  */

  241. static inline int parse_nal_units(AVCodecParserContext *s,

  242.                                   AVCodecContext *avctx,

  243.                                   const uint8_t * const buf, int buf_size)

  244. {

  245.     H264ParseContext *p = s->priv_data;

  246.     H2645NAL nal = { NULL };

  247.     int buf_index, next_avc;

  248.     unsigned int pps_id;

  249.     unsigned int slice_type;

  250.     int state = -1, got_reset = 0;

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

  252.     int field_poc[2];

  253.     int ret;

  254. 

  255.     /* set some sane default values */

  256.     s->pict_type         = AV_PICTURE_TYPE_I;

  257.     s->key_frame         = 0;

  258.     s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;

  259. 

  260.     ff_h264_sei_uninit(&p->sei);

  261.     p->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1;

  262. 

  263.     if (!buf_size)

  264.         return 0;

  265. 

  266.     buf_index     = 0;

  267.     next_avc      = p->is_avc ? 0 : buf_size;

  268.     for (;;) {

  269.         const SPS *sps;

  270.         int src_length, consumed, nalsize = 0;

  271. 

  272.         if (buf_index >= next_avc) {

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

  274.             if (nalsize < 0)

  275.                 break;

  276.             next_avc = buf_index + nalsize;

  277.         } else {

  278.             buf_index = find_start_code(buf, buf_size, buf_index, next_avc);

  279.             if (buf_index >= buf_size)

  280.                 break;

  281.             if (buf_index >= next_avc)

  282.                 continue;

  283.         }

  284.         src_length = next_avc - buf_index;

  285. 

  286.         state = buf[buf_index];

  287.         switch (state & 0x1f) {

  288.         case H264_NAL_SLICE:

  289.         case H264_NAL_IDR_SLICE:

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

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

  292.                 /* IDR or disposable slice

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

  294.                 if (src_length > 60)

  295.                     src_length = 60;

  296.             } else {

  297.                 /* To decode up to MMCOs */

  298.                 if (src_length > 1000)

  299.                     src_length = 1000;

  300.             }

  301.             break;

  302.         }

  303.         consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal, 1);

  304.         if (consumed < 0)

  305.             break;

  306. 

  307.         buf_index += consumed;

  308. 

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

  310.         if (ret < 0)

  311.             goto fail;

  312.         get_bits1(&nal.gb);

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

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

  315. 

  316.         switch (nal.type) {

  317.         case H264_NAL_SPS:

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

  319.             break;

  320.         case H264_NAL_PPS:

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

  322.                                                  nal.size_bits);

  323.             break;

  324.         case H264_NAL_SEI:

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

  326.             break;

  327.         case H264_NAL_IDR_SLICE:

  328.             s->key_frame = 1;

  329. 

  330.             p->poc.prev_frame_num        = 0;

  331.             p->poc.prev_frame_num_offset = 0;

  332.             p->poc.prev_poc_msb          =

  333.             p->poc.prev_poc_lsb          = 0;

  334.         /* fall through */

  335.         case H264_NAL_SLICE:

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

  337.             slice_type   = get_ue_golomb_31(&nal.gb);

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

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

  340.                 /* key frame, since recovery_frame_cnt is set */

  341.                 s->key_frame = 1;

  342.             }

  343.             pps_id = get_ue_golomb(&nal.gb);

  344.             if (pps_id >= MAX_PPS_COUNT) {

  345.                 av_log(avctx, AV_LOG_ERROR,

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

  347.                 goto fail;

  348.             }

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

  350.                 av_log(avctx, AV_LOG_ERROR,

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

  352.                 goto fail;

  353.             }

  354. 

  355.             av_buffer_unref(&p->ps.pps_ref);

  356.             av_buffer_unref(&p->ps.sps_ref);

  357.             p->ps.pps = NULL;

  358.             p->ps.sps = NULL;

  359.             p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);

  360.             if (!p->ps.pps_ref)

  361.                 goto fail;

  362.             p->ps.pps = (const PPS*)p->ps.pps_ref->data;

  363. 

  364.             if (!p->ps.sps_list[p->ps.pps->sps_id]) {

  365.                 av_log(avctx, AV_LOG_ERROR,

  366.                        "non-existing SPS %u referenced\n", p->ps.pps->sps_id);

  367.                 goto fail;

  368.             }

  369. 

  370.             p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]);

  371.             if (!p->ps.sps_ref)

  372.                 goto fail;

  373.             p->ps.sps = (const SPS*)p->ps.sps_ref->data;

  374. 

  375.             sps = p->ps.sps;

  376. 

  377.             // heuristic to detect non marked keyframes

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

  379.                 s->key_frame = 1;

  380. 

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

  382. 

  383.             s->coded_width  = 16 * sps->mb_width;

  384.             s->coded_height = 16 * sps->mb_height;

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

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

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

  388.                 s->width  = s->coded_width;

  389.                 s->height = s->coded_height;

  390.             }

  391. 

  392.             switch (sps->bit_depth_luma) {

  393.             case 9:

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

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

  396.                 else                                  s->format = AV_PIX_FMT_YUV420P9;

  397.                 break;

  398.             case 10:

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

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

  401.                 else                                  s->format = AV_PIX_FMT_YUV420P10;

  402.                 break;

  403.             case 8:

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

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

  406.                 else                                  s->format = AV_PIX_FMT_YUV420P;

  407.                 break;

  408.             default:

  409.                 s->format = AV_PIX_FMT_NONE;

  410.             }

  411. 

  412.             avctx->profile = ff_h264_get_profile(sps);

  413.             avctx->level   = sps->level_idc;

  414. 

  415.             if (sps->frame_mbs_only_flag) {

  416.                 p->picture_structure = PICT_FRAME;

  417.             } else {

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

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

  420.                 } else {

  421.                     p->picture_structure = PICT_FRAME;

  422.                 }

  423.             }

  424. 

  425.             if (nal.type == H264_NAL_IDR_SLICE)

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

  427.             if (sps->poc_type == 0) {

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

  429. 

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

  431.                     p->picture_structure == PICT_FRAME)

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

  433.             }

  434. 

  435.             if (sps->poc_type == 1 &&

  436.                 !sps->delta_pic_order_always_zero_flag) {

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

  438. 

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

  440.                     p->picture_structure == PICT_FRAME)

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

  442.             }

  443. 

  444.             /* Decode POC of this picture.

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

  446.             field_poc[0] = field_poc[1] = INT_MAX;

  447.             ff_h264_init_poc(field_poc, &s->output_picture_number, sps,

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

  449. 

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

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

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

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

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

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

  456.                 if (got_reset < 0)

  457.                     goto fail;

  458.             }

  459. 

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

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

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

  463.             if (nal.ref_idc != 0) {

  464.                 if (!got_reset) {

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

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

  467.                 } else {

  468.                     p->poc.prev_poc_msb = 0;

  469.                     p->poc.prev_poc_lsb =

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

  471.                 }

  472.             }

  473. 

  474.             if (sps->pic_struct_present_flag) {

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

  476.                 case SEI_PIC_STRUCT_TOP_FIELD:

  477.                 case SEI_PIC_STRUCT_BOTTOM_FIELD:

  478.                     s->repeat_pict = 0;

  479.                     break;

  480.                 case SEI_PIC_STRUCT_FRAME:

  481.                 case SEI_PIC_STRUCT_TOP_BOTTOM:

  482.                 case SEI_PIC_STRUCT_BOTTOM_TOP:

  483.                     s->repeat_pict = 1;

  484.                     break;

  485.                 case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

  486.                 case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

  487.                     s->repeat_pict = 2;

  488.                     break;

  489.                 case SEI_PIC_STRUCT_FRAME_DOUBLING:

  490.                     s->repeat_pict = 3;

  491.                     break;

  492.                 case SEI_PIC_STRUCT_FRAME_TRIPLING:

  493.                     s->repeat_pict = 5;

  494.                     break;

  495.                 default:

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

  497.                     break;

  498.                 }

  499.             } else {

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

  501.             }

  502. 

  503.             if (p->picture_structure == PICT_FRAME) {

  504.                 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

  505.                 if (sps->pic_struct_present_flag) {

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

  507.                     case SEI_PIC_STRUCT_TOP_BOTTOM:

  508.                     case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

  509.                         s->field_order = AV_FIELD_TT;

  510.                         break;

  511.                     case SEI_PIC_STRUCT_BOTTOM_TOP:

  512.                     case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

  513.                         s->field_order = AV_FIELD_BB;

  514.                         break;

  515.                     default:

  516.                         s->field_order = AV_FIELD_PROGRESSIVE;

  517.                         break;

  518.                     }

  519.                 } else {

  520.                     if (field_poc[0] < field_poc[1])

  521.                         s->field_order = AV_FIELD_TT;

  522.                     else if (field_poc[0] > field_poc[1])

  523.                         s->field_order = AV_FIELD_BB;

  524.                     else

  525.                         s->field_order = AV_FIELD_PROGRESSIVE;

  526.                 }

  527.             } else {

  528.                 if (p->picture_structure == PICT_TOP_FIELD)

  529.                     s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;

  530.                 else

  531.                     s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;

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

  533.                     p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&

  534.                     p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&

  535.                     p->last_picture_structure != s->picture_structure) {

  536.                     if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)

  537.                         s->field_order = AV_FIELD_TT;

  538.                     else

  539.                         s->field_order = AV_FIELD_BB;

  540.                 } else {

  541.                     s->field_order = AV_FIELD_UNKNOWN;

  542.                 }

  543.                 p->last_picture_structure = s->picture_structure;

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

  545.             }

  546. 

  547.             av_freep(&nal.rbsp_buffer);

  548.             return 0; /* no need to evaluate the rest */

  549.         }

  550.     }

  551.     if (q264) {

  552.         av_freep(&nal.rbsp_buffer);

  553.         return 0;

  554.     }

  555.     /* didn't find a picture! */

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

  557. fail:

  558.     av_freep(&nal.rbsp_buffer);

  559.     return -1;

  560. }

  561. 

  562. static int h264_parse(AVCodecParserContext *s,

  563.                       AVCodecContext *avctx,

  564.                       const uint8_t **poutbuf, int *poutbuf_size,

  565.                       const uint8_t *buf, int buf_size)

  566. {

  567.     H264ParseContext *p = s->priv_data;

  568.     ParseContext *pc = &p->pc;

  569.     int next;

  570. 

  571.     if (!p->got_first) {

  572.         p->got_first = 1;

  573.         if (avctx->extradata_size) {

  574.             ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,

  575.                                      &p->ps, &p->is_avc, &p->nal_length_size,

  576.                                      avctx->err_recognition, avctx);

  577.         }

  578.     }

  579. 

  580.     if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

  581.         next = buf_size;

  582.     } else {

  583.         next = h264_find_frame_end(p, buf, buf_size, avctx);

  584. 

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

  586.             *poutbuf      = NULL;

  587.             *poutbuf_size = 0;

  588.             return buf_size;

  589.         }

  590. 

  591.         if (next < 0 && next != END_NOT_FOUND) {

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

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

  594.         }

  595.     }

  596. 

  597.     parse_nal_units(s, avctx, buf, buf_size);

  598. 

  599.     if (avctx->framerate.num)

  600.         avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));

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

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

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

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

  605.     } else {

  606.         s->dts_sync_point    = INT_MIN;

  607.         s->dts_ref_dts_delta = INT_MIN;

  608.         s->pts_dts_delta     = INT_MIN;

  609.     }

  610. 

  611.     if (s->flags & PARSER_FLAG_ONCE) {

  612.         s->flags &= PARSER_FLAG_COMPLETE_FRAMES;

  613.     }

  614. 

  615.     if (s->dts_sync_point >= 0) {

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

  617.         if (den > 0) {

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

  619.             if (s->dts != AV_NOPTS_VALUE) {

  620.                 // got DTS from the stream, update reference timestamp

  621.                 p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);

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

  623.                 // compute DTS based on reference timestamp

  624.                 s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);

  625.             }

  626. 

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

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

  629. 

  630.             if (s->dts_sync_point > 0)

  631.                 p->reference_dts = s->dts; // new reference

  632.         }

  633.     }

  634. 

  635.     *poutbuf      = buf;

  636.     *poutbuf_size = buf_size;

  637.     return next;

  638. }

  639. 

  640. static int h264_split(AVCodecContext *avctx,

  641.                       const uint8_t *buf, int buf_size)

  642. {

  643.     uint32_t state = -1;

  644.     int has_sps    = 0;

  645.     int has_pps    = 0;

  646.     const uint8_t *ptr = buf, *end = buf + buf_size;

  647.     int nalu_type;

  648. 

  649.     while (ptr < end) {

  650.         ptr = avpriv_find_start_code(ptr, end, &state);

  651.         if ((state & 0xFFFFFF00) != 0x100)

  652.             break;

  653.         nalu_type = state & 0x1F;

  654.         if (nalu_type == H264_NAL_SPS) {

  655.             has_sps = 1;

  656.         } else if (nalu_type == H264_NAL_PPS)

  657.             has_pps = 1;

  658.         /* else if (nalu_type == 0x01 ||

  659.          *     nalu_type == 0x02 ||

  660.          *     nalu_type == 0x05) {

  661.          *  }

  662.          */

  663.         else if ((nalu_type != H264_NAL_SEI || has_pps) &&

  664.                   nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT &&

  665.                   nalu_type != 0x0f) {

  666.             if (has_sps) {

  667.                 while (ptr - 4 > buf && ptr[-5] == 0)

  668.                     ptr--;

  669.                 return ptr - 4 - buf;

  670.             }

  671.         }

  672.     }

  673. 

  674.     return 0;

  675. }

  676. 

  677. static void h264_close(AVCodecParserContext *s)

  678. {

  679.     H264ParseContext *p = s->priv_data;

  680.     ParseContext *pc = &p->pc;

  681. 

  682.     av_freep(&pc->buffer);

  683. 

  684.     ff_h264_sei_uninit(&p->sei);

  685.     ff_h264_ps_uninit(&p->ps);

  686. }

  687. 

  688. static av_cold int init(AVCodecParserContext *s)

  689. {

  690.     H264ParseContext *p = s->priv_data;

  691. 

  692.     p->reference_dts = AV_NOPTS_VALUE;

  693.     p->last_frame_num = INT_MAX;

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

  695.     return 0;

  696. }

  697. 

  698. AVCodecParser ff_h264_parser = {

  699.     .codec_ids      = { AV_CODEC_ID_H264 },

  700.     .priv_data_size = sizeof(H264ParseContext),

  701.     .parser_init    = init,

  702.     .parser_parse   = h264_parse,

  703.     .parser_close   = h264_close,

  704.     .split          = h264_split,

  705. };