LCOV - code coverage report
Current view: top level - libavcodec - h264dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 424 588 72.1 %
Date: 2018-02-24 03:21:38 Functions: 18 22 81.8 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... decoder
       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 codec.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #define UNCHECKED_BITSTREAM_READER 1
      29             : 
      30             : #include "libavutil/avassert.h"
      31             : #include "libavutil/display.h"
      32             : #include "libavutil/imgutils.h"
      33             : #include "libavutil/opt.h"
      34             : #include "libavutil/stereo3d.h"
      35             : #include "libavutil/timer.h"
      36             : #include "internal.h"
      37             : #include "bytestream.h"
      38             : #include "cabac.h"
      39             : #include "cabac_functions.h"
      40             : #include "error_resilience.h"
      41             : #include "avcodec.h"
      42             : #include "h264.h"
      43             : #include "h264dec.h"
      44             : #include "h2645_parse.h"
      45             : #include "h264data.h"
      46             : #include "h264chroma.h"
      47             : #include "h264_mvpred.h"
      48             : #include "h264_ps.h"
      49             : #include "golomb.h"
      50             : #include "hwaccel.h"
      51             : #include "mathops.h"
      52             : #include "me_cmp.h"
      53             : #include "mpegutils.h"
      54             : #include "profiles.h"
      55             : #include "rectangle.h"
      56             : #include "thread.h"
      57             : 
      58             : const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
      59             : 
      60       10151 : int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
      61             : {
      62       10151 :     H264Context *h = avctx->priv_data;
      63       10151 :     return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0;
      64             : }
      65             : 
      66         495 : static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
      67             :                               int (*mv)[2][4][2],
      68             :                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
      69             : {
      70         495 :     H264Context *h = opaque;
      71         495 :     H264SliceContext *sl = &h->slice_ctx[0];
      72             : 
      73         495 :     sl->mb_x = mb_x;
      74         495 :     sl->mb_y = mb_y;
      75         495 :     sl->mb_xy = mb_x + mb_y * h->mb_stride;
      76         495 :     memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
      77             :     av_assert1(ref >= 0);
      78             :     /* FIXME: It is possible albeit uncommon that slice references
      79             :      * differ between slices. We take the easy approach and ignore
      80             :      * it for now. If this turns out to have any relevance in
      81             :      * practice then correct remapping should be added. */
      82         495 :     if (ref >= sl->ref_count[0])
      83          99 :         ref = 0;
      84         495 :     if (!sl->ref_list[0][ref].data[0]) {
      85           0 :         av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
      86           0 :         ref = 0;
      87             :     }
      88         495 :     if ((sl->ref_list[0][ref].reference&3) != 3) {
      89           0 :         av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
      90           0 :         return;
      91             :     }
      92         495 :     fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
      93             :                    2, 2, 2, ref, 1);
      94         495 :     fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
      95         990 :     fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
      96         990 :                    pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
      97         495 :     sl->mb_mbaff =
      98         495 :     sl->mb_field_decoding_flag = 0;
      99         495 :     ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
     100             : }
     101             : 
     102      325682 : void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
     103             :                              int y, int height)
     104             : {
     105      325682 :     AVCodecContext *avctx = h->avctx;
     106      325682 :     const AVFrame   *src  = h->cur_pic.f;
     107      325682 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
     108      325682 :     int vshift = desc->log2_chroma_h;
     109      325682 :     const int field_pic = h->picture_structure != PICT_FRAME;
     110      325682 :     if (field_pic) {
     111       72342 :         height <<= 1;
     112       72342 :         y      <<= 1;
     113             :     }
     114             : 
     115      325682 :     height = FFMIN(height, avctx->height - y);
     116             : 
     117      325682 :     if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
     118       36196 :         return;
     119             : 
     120      289486 :     if (avctx->draw_horiz_band) {
     121             :         int offset[AV_NUM_DATA_POINTERS];
     122             :         int i;
     123             : 
     124           0 :         offset[0] = y * src->linesize[0];
     125           0 :         offset[1] =
     126           0 :         offset[2] = (y >> vshift) * src->linesize[1];
     127           0 :         for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
     128           0 :             offset[i] = 0;
     129             : 
     130           0 :         emms_c();
     131             : 
     132           0 :         avctx->draw_horiz_band(avctx, src, offset,
     133             :                                y, h->picture_structure, height);
     134             :     }
     135             : }
     136             : 
     137        1011 : void ff_h264_free_tables(H264Context *h)
     138             : {
     139             :     int i;
     140             : 
     141        1011 :     av_freep(&h->intra4x4_pred_mode);
     142        1011 :     av_freep(&h->chroma_pred_mode_table);
     143        1011 :     av_freep(&h->cbp_table);
     144        1011 :     av_freep(&h->mvd_table[0]);
     145        1011 :     av_freep(&h->mvd_table[1]);
     146        1011 :     av_freep(&h->direct_table);
     147        1011 :     av_freep(&h->non_zero_count);
     148        1011 :     av_freep(&h->slice_table_base);
     149        1011 :     h->slice_table = NULL;
     150        1011 :     av_freep(&h->list_counts);
     151             : 
     152        1011 :     av_freep(&h->mb2b_xy);
     153        1011 :     av_freep(&h->mb2br_xy);
     154             : 
     155        1011 :     av_buffer_pool_uninit(&h->qscale_table_pool);
     156        1011 :     av_buffer_pool_uninit(&h->mb_type_pool);
     157        1011 :     av_buffer_pool_uninit(&h->motion_val_pool);
     158        1011 :     av_buffer_pool_uninit(&h->ref_index_pool);
     159             : 
     160        2022 :     for (i = 0; i < h->nb_slice_ctx; i++) {
     161        1011 :         H264SliceContext *sl = &h->slice_ctx[i];
     162             : 
     163        1011 :         av_freep(&sl->dc_val_base);
     164        1011 :         av_freep(&sl->er.mb_index2xy);
     165        1011 :         av_freep(&sl->er.error_status_table);
     166        1011 :         av_freep(&sl->er.er_temp_buffer);
     167             : 
     168        1011 :         av_freep(&sl->bipred_scratchpad);
     169        1011 :         av_freep(&sl->edge_emu_buffer);
     170        1011 :         av_freep(&sl->top_borders[0]);
     171        1011 :         av_freep(&sl->top_borders[1]);
     172             : 
     173        1011 :         sl->bipred_scratchpad_allocated = 0;
     174        1011 :         sl->edge_emu_buffer_allocated   = 0;
     175        1011 :         sl->top_borders_allocated[0]    = 0;
     176        1011 :         sl->top_borders_allocated[1]    = 0;
     177             :     }
     178        1011 : }
     179             : 
     180         505 : int ff_h264_alloc_tables(H264Context *h)
     181             : {
     182         505 :     const int big_mb_num = h->mb_stride * (h->mb_height + 1);
     183         505 :     const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
     184             :     int x, y;
     185             : 
     186         505 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
     187             :                       row_mb_num, 8 * sizeof(uint8_t), fail)
     188         505 :     h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
     189             : 
     190         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
     191             :                       big_mb_num * 48 * sizeof(uint8_t), fail)
     192         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
     193             :                       (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)
     194         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
     195             :                       big_mb_num * sizeof(uint16_t), fail)
     196         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
     197             :                       big_mb_num * sizeof(uint8_t), fail)
     198         505 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
     199             :                       row_mb_num, 16 * sizeof(uint8_t), fail);
     200         505 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
     201             :                       row_mb_num, 16 * sizeof(uint8_t), fail);
     202         505 :     h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
     203         505 :     h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
     204             : 
     205         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
     206             :                       4 * big_mb_num * sizeof(uint8_t), fail);
     207         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
     208             :                       big_mb_num * sizeof(uint8_t), fail)
     209             : 
     210         505 :     memset(h->slice_table_base, -1,
     211         505 :            (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
     212         505 :     h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
     213             : 
     214         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
     215             :                       big_mb_num * sizeof(uint32_t), fail);
     216         505 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
     217             :                       big_mb_num * sizeof(uint32_t), fail);
     218       12257 :     for (y = 0; y < h->mb_height; y++)
     219      670043 :         for (x = 0; x < h->mb_width; x++) {
     220      658291 :             const int mb_xy = x + y * h->mb_stride;
     221      658291 :             const int b_xy  = 4 * x + 4 * y * h->b_stride;
     222             : 
     223      658291 :             h->mb2b_xy[mb_xy]  = b_xy;
     224      658291 :             h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
     225             :         }
     226             : 
     227         505 :     return 0;
     228             : 
     229           0 : fail:
     230           0 :     ff_h264_free_tables(h);
     231           0 :     return AVERROR(ENOMEM);
     232             : }
     233             : 
     234             : /**
     235             :  * Init context
     236             :  * Allocate buffers which are not shared amongst multiple threads.
     237             :  */
     238         505 : int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
     239             : {
     240         505 :     ERContext *er = &sl->er;
     241         505 :     int mb_array_size = h->mb_height * h->mb_stride;
     242         505 :     int y_size  = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);
     243         505 :     int c_size  = h->mb_stride * (h->mb_height + 1);
     244         505 :     int yc_size = y_size + 2   * c_size;
     245             :     int x, y, i;
     246             : 
     247        1010 :     sl->ref_cache[0][scan8[5]  + 1] =
     248        1515 :     sl->ref_cache[0][scan8[7]  + 1] =
     249        1515 :     sl->ref_cache[0][scan8[13] + 1] =
     250        1515 :     sl->ref_cache[1][scan8[5]  + 1] =
     251        1515 :     sl->ref_cache[1][scan8[7]  + 1] =
     252        1010 :     sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
     253             : 
     254         505 :     if (sl != h->slice_ctx) {
     255           0 :         memset(er, 0, sizeof(*er));
     256             :     } else
     257             :     if (CONFIG_ERROR_RESILIENCE) {
     258             : 
     259             :         /* init ER */
     260         505 :         er->avctx          = h->avctx;
     261         505 :         er->decode_mb      = h264_er_decode_mb;
     262         505 :         er->opaque         = h;
     263         505 :         er->quarter_sample = 1;
     264             : 
     265         505 :         er->mb_num      = h->mb_num;
     266         505 :         er->mb_width    = h->mb_width;
     267         505 :         er->mb_height   = h->mb_height;
     268         505 :         er->mb_stride   = h->mb_stride;
     269         505 :         er->b8_stride   = h->mb_width * 2 + 1;
     270             : 
     271             :         // error resilience code looks cleaner with this
     272         505 :         FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
     273             :                           (h->mb_num + 1) * sizeof(int), fail);
     274             : 
     275       12257 :         for (y = 0; y < h->mb_height; y++)
     276      670043 :             for (x = 0; x < h->mb_width; x++)
     277      658291 :                 er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
     278             : 
     279        2020 :         er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
     280        1515 :                                                       h->mb_stride + h->mb_width;
     281             : 
     282         505 :         FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
     283             :                           mb_array_size * sizeof(uint8_t), fail);
     284             : 
     285         505 :         FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
     286             :                          h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
     287             : 
     288         505 :         FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
     289             :                           yc_size * sizeof(int16_t), fail);
     290         505 :         er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
     291         505 :         er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
     292         505 :         er->dc_val[2] = er->dc_val[1] + c_size;
     293     4068178 :         for (i = 0; i < yc_size; i++)
     294     4067673 :             sl->dc_val_base[i] = 1024;
     295             :     }
     296             : 
     297         505 :     return 0;
     298             : 
     299           0 : fail:
     300           0 :     return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
     301             : }
     302             : 
     303         506 : static int h264_init_context(AVCodecContext *avctx, H264Context *h)
     304             : {
     305             :     int i;
     306             : 
     307         506 :     h->avctx                 = avctx;
     308         506 :     h->cur_chroma_format_idc = -1;
     309             : 
     310         506 :     h->width_from_caller     = avctx->width;
     311         506 :     h->height_from_caller    = avctx->height;
     312             : 
     313         506 :     h->picture_structure     = PICT_FRAME;
     314         506 :     h->workaround_bugs       = avctx->workaround_bugs;
     315         506 :     h->flags                 = avctx->flags;
     316         506 :     h->poc.prev_poc_msb      = 1 << 16;
     317         506 :     h->recovery_frame        = -1;
     318         506 :     h->frame_recovered       = 0;
     319         506 :     h->poc.prev_frame_num    = -1;
     320         506 :     h->sei.frame_packing.arrangement_cancel_flag = -1;
     321         506 :     h->sei.unregistered.x264_build = -1;
     322             : 
     323         506 :     h->next_outputed_poc = INT_MIN;
     324        8602 :     for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
     325        8096 :         h->last_pocs[i] = INT_MIN;
     326             : 
     327         506 :     ff_h264_sei_uninit(&h->sei);
     328             : 
     329         506 :     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
     330             : 
     331         506 :     h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
     332         506 :     h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
     333         506 :     if (!h->slice_ctx) {
     334           0 :         h->nb_slice_ctx = 0;
     335           0 :         return AVERROR(ENOMEM);
     336             :     }
     337             : 
     338       18722 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     339       18216 :         h->DPB[i].f = av_frame_alloc();
     340       18216 :         if (!h->DPB[i].f)
     341           0 :             return AVERROR(ENOMEM);
     342             :     }
     343             : 
     344         506 :     h->cur_pic.f = av_frame_alloc();
     345         506 :     if (!h->cur_pic.f)
     346           0 :         return AVERROR(ENOMEM);
     347             : 
     348         506 :     h->last_pic_for_ec.f = av_frame_alloc();
     349         506 :     if (!h->last_pic_for_ec.f)
     350           0 :         return AVERROR(ENOMEM);
     351             : 
     352        1012 :     for (i = 0; i < h->nb_slice_ctx; i++)
     353         506 :         h->slice_ctx[i].h264 = h;
     354             : 
     355         506 :     return 0;
     356             : }
     357             : 
     358         506 : static av_cold int h264_decode_end(AVCodecContext *avctx)
     359             : {
     360         506 :     H264Context *h = avctx->priv_data;
     361             :     int i;
     362             : 
     363         506 :     ff_h264_remove_all_refs(h);
     364         506 :     ff_h264_free_tables(h);
     365             : 
     366       18722 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     367       18216 :         ff_h264_unref_picture(h, &h->DPB[i]);
     368       18216 :         av_frame_free(&h->DPB[i].f);
     369             :     }
     370         506 :     memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
     371             : 
     372         506 :     h->cur_pic_ptr = NULL;
     373             : 
     374         506 :     av_freep(&h->slice_ctx);
     375         506 :     h->nb_slice_ctx = 0;
     376             : 
     377         506 :     ff_h264_sei_uninit(&h->sei);
     378         506 :     ff_h264_ps_uninit(&h->ps);
     379             : 
     380         506 :     ff_h2645_packet_uninit(&h->pkt);
     381             : 
     382         506 :     ff_h264_unref_picture(h, &h->cur_pic);
     383         506 :     av_frame_free(&h->cur_pic.f);
     384         506 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     385         506 :     av_frame_free(&h->last_pic_for_ec.f);
     386             : 
     387         506 :     return 0;
     388             : }
     389             : 
     390             : static AVOnce h264_vlc_init = AV_ONCE_INIT;
     391             : 
     392         506 : static av_cold int h264_decode_init(AVCodecContext *avctx)
     393             : {
     394         506 :     H264Context *h = avctx->priv_data;
     395             :     int ret;
     396             : 
     397         506 :     ret = h264_init_context(avctx, h);
     398         506 :     if (ret < 0)
     399           0 :         return ret;
     400             : 
     401         506 :     ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);
     402         506 :     if (ret != 0) {
     403           0 :         av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
     404           0 :         return AVERROR_UNKNOWN;
     405             :     }
     406             : 
     407         506 :     if (avctx->ticks_per_frame == 1) {
     408         506 :         if(h->avctx->time_base.den < INT_MAX/2) {
     409         506 :             h->avctx->time_base.den *= 2;
     410             :         } else
     411           0 :             h->avctx->time_base.num /= 2;
     412             :     }
     413         506 :     avctx->ticks_per_frame = 2;
     414             : 
     415         506 :     if (avctx->extradata_size > 0 && avctx->extradata) {
     416         290 :         ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
     417             :                                        &h->ps, &h->is_avc, &h->nal_length_size,
     418             :                                        avctx->err_recognition, avctx);
     419         290 :         if (ret < 0) {
     420           0 :             h264_decode_end(avctx);
     421           0 :             return ret;
     422             :         }
     423             :     }
     424             : 
     425         506 :     if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
     426           0 :         h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {
     427           0 :         h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
     428             :     }
     429             : 
     430         506 :     avctx->internal->allocate_progress = 1;
     431             : 
     432         506 :     ff_h264_flush_change(h);
     433             : 
     434         506 :     if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
     435           0 :         h->enable_er = 0;
     436             : 
     437         506 :     if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
     438           0 :         av_log(avctx, AV_LOG_WARNING,
     439             :                "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
     440             :                "Use it at your own risk\n");
     441             :     }
     442             : 
     443         506 :     return 0;
     444             : }
     445             : 
     446             : #if HAVE_THREADS
     447           0 : static int decode_init_thread_copy(AVCodecContext *avctx)
     448             : {
     449           0 :     H264Context *h = avctx->priv_data;
     450             :     int ret;
     451             : 
     452           0 :     if (!avctx->internal->is_copy)
     453           0 :         return 0;
     454             : 
     455           0 :     memset(h, 0, sizeof(*h));
     456             : 
     457           0 :     ret = h264_init_context(avctx, h);
     458           0 :     if (ret < 0)
     459           0 :         return ret;
     460             : 
     461           0 :     h->context_initialized = 0;
     462             : 
     463           0 :     return 0;
     464             : }
     465             : #endif
     466             : 
     467             : /**
     468             :  * instantaneous decoder refresh.
     469             :  */
     470        1446 : static void idr(H264Context *h)
     471             : {
     472             :     int i;
     473        1446 :     ff_h264_remove_all_refs(h);
     474        1446 :     h->poc.prev_frame_num        =
     475        1446 :     h->poc.prev_frame_num_offset = 0;
     476        1446 :     h->poc.prev_poc_msb          = 1<<16;
     477        1446 :     h->poc.prev_poc_lsb          = 0;
     478       24582 :     for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
     479       23136 :         h->last_pocs[i] = INT_MIN;
     480        1446 : }
     481             : 
     482             : /* forget old pics after a seek */
     483         512 : void ff_h264_flush_change(H264Context *h)
     484             : {
     485             :     int i, j;
     486             : 
     487         512 :     h->next_outputed_poc = INT_MIN;
     488         512 :     h->prev_interlaced_frame = 1;
     489         512 :     idr(h);
     490             : 
     491         512 :     h->poc.prev_frame_num = -1;
     492         512 :     if (h->cur_pic_ptr) {
     493           0 :         h->cur_pic_ptr->reference = 0;
     494           0 :         for (j=i=0; h->delayed_pic[i]; i++)
     495           0 :             if (h->delayed_pic[i] != h->cur_pic_ptr)
     496           0 :                 h->delayed_pic[j++] = h->delayed_pic[i];
     497           0 :         h->delayed_pic[j] = NULL;
     498             :     }
     499         512 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     500             : 
     501         512 :     h->first_field = 0;
     502         512 :     h->recovery_frame = -1;
     503         512 :     h->frame_recovered = 0;
     504         512 :     h->current_slice = 0;
     505         512 :     h->mmco_reset = 1;
     506         512 : }
     507             : 
     508             : /* forget old pics after a seek */
     509           0 : static void flush_dpb(AVCodecContext *avctx)
     510             : {
     511           0 :     H264Context *h = avctx->priv_data;
     512             :     int i;
     513             : 
     514           0 :     memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
     515             : 
     516           0 :     ff_h264_flush_change(h);
     517           0 :     ff_h264_sei_uninit(&h->sei);
     518             : 
     519           0 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
     520           0 :         ff_h264_unref_picture(h, &h->DPB[i]);
     521           0 :     h->cur_pic_ptr = NULL;
     522           0 :     ff_h264_unref_picture(h, &h->cur_pic);
     523             : 
     524           0 :     h->mb_y = 0;
     525             : 
     526           0 :     ff_h264_free_tables(h);
     527           0 :     h->context_initialized = 0;
     528           0 : }
     529             : 
     530           0 : static int get_last_needed_nal(H264Context *h)
     531             : {
     532           0 :     int nals_needed = 0;
     533           0 :     int first_slice = 0;
     534             :     int i, ret;
     535             : 
     536           0 :     for (i = 0; i < h->pkt.nb_nals; i++) {
     537           0 :         H2645NAL *nal = &h->pkt.nals[i];
     538             :         GetBitContext gb;
     539             : 
     540             :         /* packets can sometimes contain multiple PPS/SPS,
     541             :          * e.g. two PAFF field pictures in one packet, or a demuxer
     542             :          * which splits NALs strangely if so, when frame threading we
     543             :          * can't start the next thread until we've read all of them */
     544           0 :         switch (nal->type) {
     545           0 :         case H264_NAL_SPS:
     546             :         case H264_NAL_PPS:
     547           0 :             nals_needed = i;
     548           0 :             break;
     549           0 :         case H264_NAL_DPA:
     550             :         case H264_NAL_IDR_SLICE:
     551             :         case H264_NAL_SLICE:
     552           0 :             ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
     553           0 :             if (ret < 0) {
     554           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
     555           0 :                 if (h->avctx->err_recognition & AV_EF_EXPLODE)
     556           0 :                     return ret;
     557             : 
     558           0 :                 break;
     559             :             }
     560           0 :             if (!get_ue_golomb_long(&gb) ||  // first_mb_in_slice
     561           0 :                 !first_slice ||
     562           0 :                 first_slice != nal->type)
     563           0 :                 nals_needed = i;
     564           0 :             if (!first_slice)
     565           0 :                 first_slice = nal->type;
     566             :         }
     567             :     }
     568             : 
     569           0 :     return nals_needed;
     570             : }
     571             : 
     572           0 : static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
     573             : {
     574           0 :     av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
     575           0 :     av_log(logctx, AV_LOG_DEBUG, "  green_metadata_type: %d\n", gm->green_metadata_type);
     576             : 
     577           0 :     if (gm->green_metadata_type == 0) {
     578           0 :         av_log(logctx, AV_LOG_DEBUG, "  green_metadata_period_type: %d\n", gm->period_type);
     579             : 
     580           0 :         if (gm->period_type == 2)
     581           0 :             av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_seconds: %d\n", gm->num_seconds);
     582           0 :         else if (gm->period_type == 3)
     583           0 :             av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_pictures: %d\n", gm->num_pictures);
     584             : 
     585           0 :         av_log(logctx, AV_LOG_DEBUG, "  SEI GREEN Complexity Metrics: %f %f %f %f\n",
     586           0 :                (float)gm->percent_non_zero_macroblocks/255,
     587           0 :                (float)gm->percent_intra_coded_macroblocks/255,
     588           0 :                (float)gm->percent_six_tap_filtering/255,
     589           0 :                (float)gm->percent_alpha_point_deblocking_instance/255);
     590             : 
     591           0 :     } else if (gm->green_metadata_type == 1) {
     592           0 :         av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_type: %d\n", gm->xsd_metric_type);
     593             : 
     594           0 :         if (gm->xsd_metric_type == 0)
     595           0 :             av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_value: %f\n",
     596           0 :                    (float)gm->xsd_metric_value/100);
     597             :     }
     598           0 : }
     599             : 
     600       25439 : static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
     601             : {
     602       25439 :     AVCodecContext *const avctx = h->avctx;
     603       25439 :     int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
     604       25439 :     int idr_cleared=0;
     605       25439 :     int i, ret = 0;
     606             : 
     607       25439 :     h->has_slice = 0;
     608       25439 :     h->nal_unit_type= 0;
     609             : 
     610       25439 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
     611       25439 :         h->current_slice = 0;
     612       25439 :         if (!h->first_field)
     613       22234 :             h->cur_pic_ptr = NULL;
     614       25439 :         ff_h264_sei_uninit(&h->sei);
     615             :     }
     616             : 
     617       25439 :     if (h->nal_length_size == 4) {
     618        2506 :         if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
     619           0 :             h->is_avc = 0;
     620        2506 :         }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
     621        2506 :             h->is_avc = 1;
     622             :     }
     623             : 
     624       25439 :     ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
     625       25439 :                                 h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);
     626       25439 :     if (ret < 0) {
     627           1 :         av_log(avctx, AV_LOG_ERROR,
     628             :                "Error splitting the input into NAL units.\n");
     629           1 :         return ret;
     630             :     }
     631             : 
     632       25438 :     if (avctx->active_thread_type & FF_THREAD_FRAME)
     633           0 :         nals_needed = get_last_needed_nal(h);
     634       25438 :     if (nals_needed < 0)
     635           0 :         return nals_needed;
     636             : 
     637       68718 :     for (i = 0; i < h->pkt.nb_nals; i++) {
     638       43280 :         H2645NAL *nal = &h->pkt.nals[i];
     639             :         int max_slice_ctx, err;
     640             : 
     641       44208 :         if (avctx->skip_frame >= AVDISCARD_NONREF &&
     642        1752 :             nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
     643         504 :             continue;
     644             : 
     645             :         // FIXME these should stop being context-global variables
     646       42776 :         h->nal_ref_idc   = nal->ref_idc;
     647       42776 :         h->nal_unit_type = nal->type;
     648             : 
     649       42776 :         err = 0;
     650       42776 :         switch (nal->type) {
     651        1972 :         case H264_NAL_IDR_SLICE:
     652        1972 :             if ((nal->data[1] & 0xFC) == 0x98) {
     653           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
     654           0 :                 h->next_outputed_poc = INT_MIN;
     655           0 :                 ret = -1;
     656           0 :                 goto end;
     657             :             }
     658        1972 :             if(!idr_cleared) {
     659         934 :                 if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {
     660           0 :                     av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");
     661           0 :                     ret = AVERROR_INVALIDDATA;
     662           0 :                     goto end;
     663             :                 }
     664         934 :                 idr(h); // FIXME ensure we don't lose some frames if there is reordering
     665             :             }
     666        1972 :             idr_cleared = 1;
     667        1972 :             h->has_recovery_point = 1;
     668       31511 :         case H264_NAL_SLICE:
     669       31511 :             h->has_slice = 1;
     670             : 
     671       31511 :             if ((err = ff_h264_queue_decode_slice(h, nal))) {
     672          23 :                 H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
     673          23 :                 sl->ref_count[0] = sl->ref_count[1] = 0;
     674          23 :                 break;
     675             :             }
     676             : 
     677       31488 :             if (h->current_slice == 1) {
     678       25097 :                 if (avctx->active_thread_type & FF_THREAD_FRAME &&
     679           0 :                     i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
     680           0 :                     ff_thread_finish_setup(avctx);
     681           0 :                     h->setup_finished = 1;
     682             :                 }
     683             : 
     684       25097 :                 if (h->avctx->hwaccel &&
     685           0 :                     (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
     686           0 :                     goto end;
     687             :             }
     688             : 
     689       31488 :             max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
     690       31488 :             if (h->nb_slice_ctx_queued == max_slice_ctx) {
     691       31407 :                 if (h->avctx->hwaccel) {
     692           0 :                     ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
     693           0 :                     h->nb_slice_ctx_queued = 0;
     694             :                 } else
     695       31407 :                     ret = ff_h264_execute_decode_slices(h);
     696       31407 :                 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     697           0 :                     goto end;
     698             :             }
     699       31488 :             break;
     700           0 :         case H264_NAL_DPA:
     701             :         case H264_NAL_DPB:
     702             :         case H264_NAL_DPC:
     703           0 :             avpriv_request_sample(avctx, "data partitioning");
     704           0 :             break;
     705        1495 :         case H264_NAL_SEI:
     706        1495 :             ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
     707        1495 :             h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;
     708        1495 :             if (avctx->debug & FF_DEBUG_GREEN_MD)
     709           0 :                 debug_green_metadata(&h->sei.green_metadata, h->avctx);
     710        1495 :             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     711           0 :                 goto end;
     712        1495 :             break;
     713         967 :         case H264_NAL_SPS: {
     714         967 :             GetBitContext tmp_gb = nal->gb;
     715         967 :             if (avctx->hwaccel && avctx->hwaccel->decode_params) {
     716           0 :                 ret = avctx->hwaccel->decode_params(avctx,
     717             :                                                     nal->type,
     718             :                                                     nal->raw_data,
     719           0 :                                                     nal->raw_size);
     720           0 :                 if (ret < 0)
     721           0 :                     goto end;
     722             :             }
     723         967 :             if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
     724        1932 :                 break;
     725           2 :             av_log(h->avctx, AV_LOG_DEBUG,
     726             :                    "SPS decoding failure, trying again with the complete NAL\n");
     727           2 :             init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
     728           2 :             if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
     729           2 :                 break;
     730           0 :             ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
     731           0 :             break;
     732             :         }
     733        6546 :         case H264_NAL_PPS:
     734        6546 :             if (avctx->hwaccel && avctx->hwaccel->decode_params) {
     735           0 :                 ret = avctx->hwaccel->decode_params(avctx,
     736             :                                                     nal->type,
     737             :                                                     nal->raw_data,
     738           0 :                                                     nal->raw_size);
     739           0 :                 if (ret < 0)
     740           0 :                     goto end;
     741             :             }
     742        6546 :             ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
     743             :                                                        nal->size_bits);
     744        6546 :             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     745           0 :                 goto end;
     746        6546 :             break;
     747        2257 :         case H264_NAL_AUD:
     748             :         case H264_NAL_END_SEQUENCE:
     749             :         case H264_NAL_END_STREAM:
     750             :         case H264_NAL_FILLER_DATA:
     751             :         case H264_NAL_SPS_EXT:
     752             :         case H264_NAL_AUXILIARY_SLICE:
     753        2257 :             break;
     754           0 :         default:
     755           0 :             av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
     756             :                    nal->type, nal->size_bits);
     757             :         }
     758             : 
     759       42776 :         if (err < 0) {
     760          23 :             av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
     761             :         }
     762             :     }
     763             : 
     764       25438 :     ret = ff_h264_execute_decode_slices(h);
     765       25438 :     if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     766           0 :         goto end;
     767             : 
     768       25438 :     ret = 0;
     769       25438 : end:
     770             : 
     771             : #if CONFIG_ERROR_RESILIENCE
     772             :     /*
     773             :      * FIXME: Error handling code does not seem to support interlaced
     774             :      * when slices span multiple rows
     775             :      * The ff_er_add_slice calls don't work right for bottom
     776             :      * fields; they cause massive erroneous error concealing
     777             :      * Error marking covers both fields (top and bottom).
     778             :      * This causes a mismatched s->error_count
     779             :      * and a bad error table. Further, the error count goes to
     780             :      * INT_MAX when called for bottom field, because mb_y is
     781             :      * past end by one (callers fault) and resync_mb_y != 0
     782             :      * causes problems for the first MB line, too.
     783             :      */
     784       44064 :     if (!FIELD_PICTURE(h) && h->current_slice &&
     785       37252 :         h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
     786       18626 :         h->enable_er) {
     787             : 
     788       18626 :         H264SliceContext *sl = h->slice_ctx;
     789       18626 :         int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
     790             : 
     791       18626 :         ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);
     792             : 
     793       18626 :         if (use_last_pic) {
     794         436 :             ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
     795         436 :             sl->ref_list[0][0].parent = &h->last_pic_for_ec;
     796         436 :             memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
     797         436 :             memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
     798         436 :             sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
     799       18190 :         } else if (sl->ref_count[0]) {
     800       16302 :             ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
     801             :         } else
     802        1888 :             ff_h264_set_erpic(&sl->er.last_pic, NULL);
     803             : 
     804       18626 :         if (sl->ref_count[1])
     805       16302 :             ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
     806             : 
     807       18626 :         sl->er.ref_count = sl->ref_count[0];
     808             : 
     809       18626 :         ff_er_frame_end(&sl->er);
     810       18626 :         if (use_last_pic)
     811         436 :             memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
     812             :     }
     813             : #endif /* CONFIG_ERROR_RESILIENCE */
     814             :     /* clean up */
     815       25438 :     if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
     816       16093 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
     817       16093 :                                   h->picture_structure == PICT_BOTTOM_FIELD);
     818             :     }
     819             : 
     820       25438 :     return (ret < 0) ? ret : buf_size;
     821             : }
     822             : 
     823             : /**
     824             :  * Return the number of bytes consumed for building the current frame.
     825             :  */
     826       24904 : static int get_consumed_bytes(int pos, int buf_size)
     827             : {
     828       24904 :     if (pos == 0)
     829           0 :         pos = 1;        // avoid infinite loops (I doubt that is needed but...)
     830       24904 :     if (pos + 10 > buf_size)
     831       24904 :         pos = buf_size; // oops ;)
     832             : 
     833       24904 :     return pos;
     834             : }
     835             : 
     836       21353 : static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
     837             : {
     838       21353 :     AVFrame *src = srcp->f;
     839             :     int ret;
     840             : 
     841       21353 :     if (src->format == AV_PIX_FMT_VIDEOTOOLBOX && src->buf[0]->size == 1)
     842           0 :         return AVERROR_INVALIDDATA;
     843             : 
     844       21353 :     ret = av_frame_ref(dst, src);
     845       21353 :     if (ret < 0)
     846           0 :         return ret;
     847             : 
     848       21353 :     av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
     849             : 
     850       21353 :     if (srcp->sei_recovery_frame_cnt == 0)
     851          23 :         dst->key_frame = 1;
     852             : 
     853       21353 :     return 0;
     854             : }
     855             : 
     856           4 : static int is_extra(const uint8_t *buf, int buf_size)
     857             : {
     858           4 :     int cnt= buf[5]&0x1f;
     859           4 :     const uint8_t *p= buf+6;
     860          12 :     while(cnt--){
     861           4 :         int nalsize= AV_RB16(p) + 2;
     862           4 :         if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
     863           0 :             return 0;
     864           4 :         p += nalsize;
     865             :     }
     866           4 :     cnt = *(p++);
     867           4 :     if(!cnt)
     868           0 :         return 0;
     869          12 :     while(cnt--){
     870           4 :         int nalsize= AV_RB16(p) + 2;
     871           4 :         if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
     872           0 :             return 0;
     873           4 :         p += nalsize;
     874             :     }
     875           4 :     return 1;
     876             : }
     877             : 
     878       21353 : static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
     879             : {
     880             :     int ret;
     881             : 
     882       42706 :     if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
     883       42706 :          (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
     884       21353 :          out->recovered)) {
     885             : 
     886       42706 :         if (!h->avctx->hwaccel &&
     887       42706 :             (out->field_poc[0] == INT_MAX ||
     888       21353 :              out->field_poc[1] == INT_MAX)
     889             :            ) {
     890             :             int p;
     891           0 :             AVFrame *f = out->f;
     892           0 :             int field = out->field_poc[0] == INT_MAX;
     893             :             uint8_t *dst_data[4];
     894             :             int linesizes[4];
     895             :             const uint8_t *src_data[4];
     896             : 
     897           0 :             av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
     898             : 
     899           0 :             for (p = 0; p<4; p++) {
     900           0 :                 dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
     901           0 :                 src_data[p] = f->data[p] +  field   *f->linesize[p];
     902           0 :                 linesizes[p] = 2*f->linesize[p];
     903             :             }
     904             : 
     905           0 :             av_image_copy(dst_data, linesizes, src_data, linesizes,
     906           0 :                           f->format, f->width, f->height>>1);
     907             :         }
     908             : 
     909       21353 :         ret = output_frame(h, dst, out);
     910       21353 :         if (ret < 0)
     911           0 :             return ret;
     912             : 
     913       21353 :         *got_frame = 1;
     914             : 
     915             :         if (CONFIG_MPEGVIDEO) {
     916       42706 :             ff_print_debug_info2(h->avctx, dst, NULL,
     917             :                                  out->mb_type,
     918             :                                  out->qscale_table,
     919       21353 :                                  out->motion_val,
     920             :                                  NULL,
     921             :                                  h->mb_width, h->mb_height, h->mb_stride, 1);
     922             :         }
     923             :     }
     924             : 
     925       21353 :     return 0;
     926             : }
     927             : 
     928         500 : static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame,
     929             :                                    int *got_frame, int buf_index)
     930             : {
     931             :     int ret, i, out_idx;
     932         500 :     H264Picture *out = h->delayed_pic[0];
     933             : 
     934         500 :     h->cur_pic_ptr = NULL;
     935         500 :     h->first_field = 0;
     936             : 
     937         500 :     out_idx = 0;
     938        1518 :     for (i = 1;
     939        1543 :          h->delayed_pic[i] &&
     940        1043 :          !h->delayed_pic[i]->f->key_frame &&
     941         518 :          !h->delayed_pic[i]->mmco_reset;
     942         518 :          i++)
     943         518 :         if (h->delayed_pic[i]->poc < out->poc) {
     944         102 :             out     = h->delayed_pic[i];
     945         102 :             out_idx = i;
     946             :         }
     947             : 
     948        1239 :     for (i = out_idx; h->delayed_pic[i]; i++)
     949         739 :         h->delayed_pic[i] = h->delayed_pic[i + 1];
     950             : 
     951         500 :     if (out) {
     952         259 :         out->reference &= ~DELAYED_PIC_REF;
     953         259 :         ret = finalize_frame(h, dst_frame, out, got_frame);
     954         259 :         if (ret < 0)
     955           0 :             return ret;
     956             :     }
     957             : 
     958         500 :     return buf_index;
     959             : }
     960             : 
     961       25939 : static int h264_decode_frame(AVCodecContext *avctx, void *data,
     962             :                              int *got_frame, AVPacket *avpkt)
     963             : {
     964       25939 :     const uint8_t *buf = avpkt->data;
     965       25939 :     int buf_size       = avpkt->size;
     966       25939 :     H264Context *h     = avctx->priv_data;
     967       25939 :     AVFrame *pict      = data;
     968             :     int buf_index;
     969             :     int ret;
     970             : 
     971       25939 :     h->flags = avctx->flags;
     972       25939 :     h->setup_finished = 0;
     973       25939 :     h->nb_slice_ctx_queued = 0;
     974             : 
     975       25939 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     976             : 
     977             :     /* end of stream, output what is still in the buffers */
     978       25939 :     if (buf_size == 0)
     979         500 :         return send_next_delayed_frame(h, pict, got_frame, 0);
     980             : 
     981       25439 :     if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
     982             :         int side_size;
     983           4 :         uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
     984           4 :         if (is_extra(side, side_size))
     985           4 :             ff_h264_decode_extradata(side, side_size,
     986             :                                      &h->ps, &h->is_avc, &h->nal_length_size,
     987             :                                      avctx->err_recognition, avctx);
     988             :     }
     989       25439 :     if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){
     990           0 :         if (is_extra(buf, buf_size))
     991           0 :             return ff_h264_decode_extradata(buf, buf_size,
     992             :                                             &h->ps, &h->is_avc, &h->nal_length_size,
     993             :                                             avctx->err_recognition, avctx);
     994             :     }
     995             : 
     996       25439 :     buf_index = decode_nal_units(h, buf, buf_size);
     997       25439 :     if (buf_index < 0)
     998           1 :         return AVERROR_INVALIDDATA;
     999             : 
    1000       25438 :     if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {
    1001           0 :         av_assert0(buf_index <= buf_size);
    1002           0 :         return send_next_delayed_frame(h, pict, got_frame, buf_index);
    1003             :     }
    1004             : 
    1005       25438 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
    1006         534 :         if (avctx->skip_frame >= AVDISCARD_NONREF ||
    1007         334 :             buf_size >= 4 && !memcmp("Q264", buf, 4))
    1008         200 :             return buf_size;
    1009         334 :         av_log(avctx, AV_LOG_ERROR, "no frame!\n");
    1010         334 :         return AVERROR_INVALIDDATA;
    1011             :     }
    1012             : 
    1013       24904 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
    1014           0 :         (h->mb_y >= h->mb_height && h->mb_height)) {
    1015       24904 :         if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
    1016           0 :             return ret;
    1017             : 
    1018             :         /* Wait for second field. */
    1019       24904 :         if (h->next_output_pic) {
    1020       21094 :             ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
    1021       21094 :             if (ret < 0)
    1022           0 :                 return ret;
    1023             :         }
    1024             :     }
    1025             : 
    1026       24904 :     av_assert0(pict->buf[0] || !*got_frame);
    1027             : 
    1028       24904 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
    1029             : 
    1030       24904 :     return get_consumed_bytes(buf_index, buf_size);
    1031             : }
    1032             : 
    1033             : #define OFFSET(x) offsetof(H264Context, x)
    1034             : #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
    1035             : static const AVOption h264_options[] = {
    1036             :     { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
    1037             :     { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
    1038             :     { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
    1039             :     { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD },
    1040             :     { NULL },
    1041             : };
    1042             : 
    1043             : static const AVClass h264_class = {
    1044             :     .class_name = "H264 Decoder",
    1045             :     .item_name  = av_default_item_name,
    1046             :     .option     = h264_options,
    1047             :     .version    = LIBAVUTIL_VERSION_INT,
    1048             : };
    1049             : 
    1050             : AVCodec ff_h264_decoder = {
    1051             :     .name                  = "h264",
    1052             :     .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
    1053             :     .type                  = AVMEDIA_TYPE_VIDEO,
    1054             :     .id                    = AV_CODEC_ID_H264,
    1055             :     .priv_data_size        = sizeof(H264Context),
    1056             :     .init                  = h264_decode_init,
    1057             :     .close                 = h264_decode_end,
    1058             :     .decode                = h264_decode_frame,
    1059             :     .capabilities          = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |
    1060             :                              AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS |
    1061             :                              AV_CODEC_CAP_FRAME_THREADS,
    1062             :     .hw_configs            = (const AVCodecHWConfigInternal*[]) {
    1063             : #if CONFIG_H264_DXVA2_HWACCEL
    1064             :                                HWACCEL_DXVA2(h264),
    1065             : #endif
    1066             : #if CONFIG_H264_D3D11VA_HWACCEL
    1067             :                                HWACCEL_D3D11VA(h264),
    1068             : #endif
    1069             : #if CONFIG_H264_D3D11VA2_HWACCEL
    1070             :                                HWACCEL_D3D11VA2(h264),
    1071             : #endif
    1072             : #if CONFIG_H264_NVDEC_HWACCEL
    1073             :                                HWACCEL_NVDEC(h264),
    1074             : #endif
    1075             : #if CONFIG_H264_VAAPI_HWACCEL
    1076             :                                HWACCEL_VAAPI(h264),
    1077             : #endif
    1078             : #if CONFIG_H264_VDPAU_HWACCEL
    1079             :                                HWACCEL_VDPAU(h264),
    1080             : #endif
    1081             : #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
    1082             :                                HWACCEL_VIDEOTOOLBOX(h264),
    1083             : #endif
    1084             :                                NULL
    1085             :                            },
    1086             :     .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
    1087             :     .flush                 = flush_dpb,
    1088             :     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
    1089             :     .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
    1090             :     .profiles              = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
    1091             :     .priv_class            = &h264_class,
    1092             : };

Generated by: LCOV version 1.13