LCOV - code coverage report
Current view: top level - libavcodec - h264dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 425 589 72.2 %
Date: 2017-12-13 02:34:56 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       10099 : int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
      61             : {
      62       10099 :     H264Context *h = avctx->priv_data;
      63       10099 :     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      325726 : void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
     103             :                              int y, int height)
     104             : {
     105      325726 :     AVCodecContext *avctx = h->avctx;
     106      325726 :     const AVFrame   *src  = h->cur_pic.f;
     107      325726 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
     108      325726 :     int vshift = desc->log2_chroma_h;
     109      325726 :     const int field_pic = h->picture_structure != PICT_FRAME;
     110      325726 :     if (field_pic) {
     111       72342 :         height <<= 1;
     112       72342 :         y      <<= 1;
     113             :     }
     114             : 
     115      325726 :     height = FFMIN(height, avctx->height - y);
     116             : 
     117      325726 :     if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
     118       36196 :         return;
     119             : 
     120      289530 :     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        1002 : void ff_h264_free_tables(H264Context *h)
     138             : {
     139             :     int i;
     140             : 
     141        1002 :     av_freep(&h->intra4x4_pred_mode);
     142        1002 :     av_freep(&h->chroma_pred_mode_table);
     143        1002 :     av_freep(&h->cbp_table);
     144        1002 :     av_freep(&h->mvd_table[0]);
     145        1002 :     av_freep(&h->mvd_table[1]);
     146        1002 :     av_freep(&h->direct_table);
     147        1002 :     av_freep(&h->non_zero_count);
     148        1002 :     av_freep(&h->slice_table_base);
     149        1002 :     h->slice_table = NULL;
     150        1002 :     av_freep(&h->list_counts);
     151             : 
     152        1002 :     av_freep(&h->mb2b_xy);
     153        1002 :     av_freep(&h->mb2br_xy);
     154             : 
     155        1002 :     av_buffer_pool_uninit(&h->qscale_table_pool);
     156        1002 :     av_buffer_pool_uninit(&h->mb_type_pool);
     157        1002 :     av_buffer_pool_uninit(&h->motion_val_pool);
     158        1002 :     av_buffer_pool_uninit(&h->ref_index_pool);
     159             : 
     160        2004 :     for (i = 0; i < h->nb_slice_ctx; i++) {
     161        1002 :         H264SliceContext *sl = &h->slice_ctx[i];
     162             : 
     163        1002 :         av_freep(&sl->dc_val_base);
     164        1002 :         av_freep(&sl->er.mb_index2xy);
     165        1002 :         av_freep(&sl->er.error_status_table);
     166        1002 :         av_freep(&sl->er.er_temp_buffer);
     167             : 
     168        1002 :         av_freep(&sl->bipred_scratchpad);
     169        1002 :         av_freep(&sl->edge_emu_buffer);
     170        1002 :         av_freep(&sl->top_borders[0]);
     171        1002 :         av_freep(&sl->top_borders[1]);
     172             : 
     173        1002 :         sl->bipred_scratchpad_allocated = 0;
     174        1002 :         sl->edge_emu_buffer_allocated   = 0;
     175        1002 :         sl->top_borders_allocated[0]    = 0;
     176        1002 :         sl->top_borders_allocated[1]    = 0;
     177             :     }
     178        1002 : }
     179             : 
     180         502 : int ff_h264_alloc_tables(H264Context *h)
     181             : {
     182         502 :     const int big_mb_num = h->mb_stride * (h->mb_height + 1);
     183         502 :     const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
     184             :     int x, y;
     185             : 
     186         502 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
     187             :                       row_mb_num, 8 * sizeof(uint8_t), fail)
     188         502 :     h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
     189             : 
     190         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
     191             :                       big_mb_num * 48 * sizeof(uint8_t), fail)
     192         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
     193             :                       (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)
     194         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
     195             :                       big_mb_num * sizeof(uint16_t), fail)
     196         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
     197             :                       big_mb_num * sizeof(uint8_t), fail)
     198         502 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
     199             :                       row_mb_num, 16 * sizeof(uint8_t), fail);
     200         502 :     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
     201             :                       row_mb_num, 16 * sizeof(uint8_t), fail);
     202         502 :     h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
     203         502 :     h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
     204             : 
     205         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
     206             :                       4 * big_mb_num * sizeof(uint8_t), fail);
     207         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
     208             :                       big_mb_num * sizeof(uint8_t), fail)
     209             : 
     210         502 :     memset(h->slice_table_base, -1,
     211         502 :            (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
     212         502 :     h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
     213             : 
     214         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
     215             :                       big_mb_num * sizeof(uint32_t), fail);
     216         502 :     FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
     217             :                       big_mb_num * sizeof(uint32_t), fail);
     218       12209 :     for (y = 0; y < h->mb_height; y++)
     219      669098 :         for (x = 0; x < h->mb_width; x++) {
     220      657391 :             const int mb_xy = x + y * h->mb_stride;
     221      657391 :             const int b_xy  = 4 * x + 4 * y * h->b_stride;
     222             : 
     223      657391 :             h->mb2b_xy[mb_xy]  = b_xy;
     224      657391 :             h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
     225             :         }
     226             : 
     227         502 :     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         502 : int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
     239             : {
     240         502 :     ERContext *er = &sl->er;
     241         502 :     int mb_array_size = h->mb_height * h->mb_stride;
     242         502 :     int y_size  = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);
     243         502 :     int c_size  = h->mb_stride * (h->mb_height + 1);
     244         502 :     int yc_size = y_size + 2   * c_size;
     245             :     int x, y, i;
     246             : 
     247        1004 :     sl->ref_cache[0][scan8[5]  + 1] =
     248        1506 :     sl->ref_cache[0][scan8[7]  + 1] =
     249        1506 :     sl->ref_cache[0][scan8[13] + 1] =
     250        1506 :     sl->ref_cache[1][scan8[5]  + 1] =
     251        1506 :     sl->ref_cache[1][scan8[7]  + 1] =
     252        1004 :     sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
     253             : 
     254         502 :     if (sl != h->slice_ctx) {
     255           0 :         memset(er, 0, sizeof(*er));
     256             :     } else
     257             :     if (CONFIG_ERROR_RESILIENCE) {
     258             : 
     259             :         /* init ER */
     260         502 :         er->avctx          = h->avctx;
     261         502 :         er->decode_mb      = h264_er_decode_mb;
     262         502 :         er->opaque         = h;
     263         502 :         er->quarter_sample = 1;
     264             : 
     265         502 :         er->mb_num      = h->mb_num;
     266         502 :         er->mb_width    = h->mb_width;
     267         502 :         er->mb_height   = h->mb_height;
     268         502 :         er->mb_stride   = h->mb_stride;
     269         502 :         er->b8_stride   = h->mb_width * 2 + 1;
     270             : 
     271             :         // error resilience code looks cleaner with this
     272         502 :         FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
     273             :                           (h->mb_num + 1) * sizeof(int), fail);
     274             : 
     275       12209 :         for (y = 0; y < h->mb_height; y++)
     276      669098 :             for (x = 0; x < h->mb_width; x++)
     277      657391 :                 er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
     278             : 
     279        2008 :         er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
     280        1506 :                                                       h->mb_stride + h->mb_width;
     281             : 
     282         502 :         FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
     283             :                           mb_array_size * sizeof(uint8_t), fail);
     284             : 
     285         502 :         FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
     286             :                          h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
     287             : 
     288         502 :         FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
     289             :                           yc_size * sizeof(int16_t), fail);
     290         502 :         er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
     291         502 :         er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
     292         502 :         er->dc_val[2] = er->dc_val[1] + c_size;
     293     4062346 :         for (i = 0; i < yc_size; i++)
     294     4061844 :             sl->dc_val_base[i] = 1024;
     295             :     }
     296             : 
     297         502 :     return 0;
     298             : 
     299           0 : fail:
     300           0 :     return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
     301             : }
     302             : 
     303         500 : static int h264_init_context(AVCodecContext *avctx, H264Context *h)
     304             : {
     305             :     int i;
     306             : 
     307         500 :     h->avctx                 = avctx;
     308         500 :     h->cur_chroma_format_idc = -1;
     309             : 
     310         500 :     h->width_from_caller     = avctx->width;
     311         500 :     h->height_from_caller    = avctx->height;
     312             : 
     313         500 :     h->picture_structure     = PICT_FRAME;
     314         500 :     h->workaround_bugs       = avctx->workaround_bugs;
     315         500 :     h->flags                 = avctx->flags;
     316         500 :     h->poc.prev_poc_msb      = 1 << 16;
     317         500 :     h->recovery_frame        = -1;
     318         500 :     h->x264_build            = -1;
     319         500 :     h->frame_recovered       = 0;
     320         500 :     h->poc.prev_frame_num    = -1;
     321         500 :     h->sei.frame_packing.arrangement_cancel_flag = -1;
     322         500 :     h->sei.unregistered.x264_build = -1;
     323             : 
     324         500 :     h->next_outputed_poc = INT_MIN;
     325        8500 :     for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
     326        8000 :         h->last_pocs[i] = INT_MIN;
     327             : 
     328         500 :     ff_h264_sei_uninit(&h->sei);
     329             : 
     330         500 :     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
     331             : 
     332         500 :     h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
     333         500 :     h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
     334         500 :     if (!h->slice_ctx) {
     335           0 :         h->nb_slice_ctx = 0;
     336           0 :         return AVERROR(ENOMEM);
     337             :     }
     338             : 
     339       18500 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     340       18000 :         h->DPB[i].f = av_frame_alloc();
     341       18000 :         if (!h->DPB[i].f)
     342           0 :             return AVERROR(ENOMEM);
     343             :     }
     344             : 
     345         500 :     h->cur_pic.f = av_frame_alloc();
     346         500 :     if (!h->cur_pic.f)
     347           0 :         return AVERROR(ENOMEM);
     348             : 
     349         500 :     h->last_pic_for_ec.f = av_frame_alloc();
     350         500 :     if (!h->last_pic_for_ec.f)
     351           0 :         return AVERROR(ENOMEM);
     352             : 
     353        1000 :     for (i = 0; i < h->nb_slice_ctx; i++)
     354         500 :         h->slice_ctx[i].h264 = h;
     355             : 
     356         500 :     return 0;
     357             : }
     358             : 
     359         500 : static av_cold int h264_decode_end(AVCodecContext *avctx)
     360             : {
     361         500 :     H264Context *h = avctx->priv_data;
     362             :     int i;
     363             : 
     364         500 :     ff_h264_remove_all_refs(h);
     365         500 :     ff_h264_free_tables(h);
     366             : 
     367       18500 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     368       18000 :         ff_h264_unref_picture(h, &h->DPB[i]);
     369       18000 :         av_frame_free(&h->DPB[i].f);
     370             :     }
     371         500 :     memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
     372             : 
     373         500 :     h->cur_pic_ptr = NULL;
     374             : 
     375         500 :     av_freep(&h->slice_ctx);
     376         500 :     h->nb_slice_ctx = 0;
     377             : 
     378         500 :     ff_h264_sei_uninit(&h->sei);
     379         500 :     ff_h264_ps_uninit(&h->ps);
     380             : 
     381         500 :     ff_h2645_packet_uninit(&h->pkt);
     382             : 
     383         500 :     ff_h264_unref_picture(h, &h->cur_pic);
     384         500 :     av_frame_free(&h->cur_pic.f);
     385         500 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     386         500 :     av_frame_free(&h->last_pic_for_ec.f);
     387             : 
     388         500 :     return 0;
     389             : }
     390             : 
     391             : static AVOnce h264_vlc_init = AV_ONCE_INIT;
     392             : 
     393         500 : static av_cold int h264_decode_init(AVCodecContext *avctx)
     394             : {
     395         500 :     H264Context *h = avctx->priv_data;
     396             :     int ret;
     397             : 
     398         500 :     ret = h264_init_context(avctx, h);
     399         500 :     if (ret < 0)
     400           0 :         return ret;
     401             : 
     402         500 :     ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);
     403         500 :     if (ret != 0) {
     404           0 :         av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
     405           0 :         return AVERROR_UNKNOWN;
     406             :     }
     407             : 
     408         500 :     if (avctx->ticks_per_frame == 1) {
     409         500 :         if(h->avctx->time_base.den < INT_MAX/2) {
     410         500 :             h->avctx->time_base.den *= 2;
     411             :         } else
     412           0 :             h->avctx->time_base.num /= 2;
     413             :     }
     414         500 :     avctx->ticks_per_frame = 2;
     415             : 
     416         500 :     if (avctx->extradata_size > 0 && avctx->extradata) {
     417         284 :         ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
     418             :                                        &h->ps, &h->is_avc, &h->nal_length_size,
     419             :                                        avctx->err_recognition, avctx);
     420         284 :         if (ret < 0) {
     421           0 :             h264_decode_end(avctx);
     422           0 :             return ret;
     423             :         }
     424             :     }
     425             : 
     426         500 :     if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
     427           0 :         h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {
     428           0 :         h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
     429             :     }
     430             : 
     431         500 :     avctx->internal->allocate_progress = 1;
     432             : 
     433         500 :     ff_h264_flush_change(h);
     434             : 
     435         500 :     if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
     436           0 :         h->enable_er = 0;
     437             : 
     438         500 :     if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
     439           0 :         av_log(avctx, AV_LOG_WARNING,
     440             :                "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
     441             :                "Use it at your own risk\n");
     442             :     }
     443             : 
     444         500 :     return 0;
     445             : }
     446             : 
     447             : #if HAVE_THREADS
     448           0 : static int decode_init_thread_copy(AVCodecContext *avctx)
     449             : {
     450           0 :     H264Context *h = avctx->priv_data;
     451             :     int ret;
     452             : 
     453           0 :     if (!avctx->internal->is_copy)
     454           0 :         return 0;
     455             : 
     456           0 :     memset(h, 0, sizeof(*h));
     457             : 
     458           0 :     ret = h264_init_context(avctx, h);
     459           0 :     if (ret < 0)
     460           0 :         return ret;
     461             : 
     462           0 :     h->context_initialized = 0;
     463             : 
     464           0 :     return 0;
     465             : }
     466             : #endif
     467             : 
     468             : /**
     469             :  * instantaneous decoder refresh.
     470             :  */
     471        1437 : static void idr(H264Context *h)
     472             : {
     473             :     int i;
     474        1437 :     ff_h264_remove_all_refs(h);
     475        1437 :     h->poc.prev_frame_num        =
     476        1437 :     h->poc.prev_frame_num_offset = 0;
     477        1437 :     h->poc.prev_poc_msb          = 1<<16;
     478        1437 :     h->poc.prev_poc_lsb          = 0;
     479       24429 :     for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
     480       22992 :         h->last_pocs[i] = INT_MIN;
     481        1437 : }
     482             : 
     483             : /* forget old pics after a seek */
     484         506 : void ff_h264_flush_change(H264Context *h)
     485             : {
     486             :     int i, j;
     487             : 
     488         506 :     h->next_outputed_poc = INT_MIN;
     489         506 :     h->prev_interlaced_frame = 1;
     490         506 :     idr(h);
     491             : 
     492         506 :     h->poc.prev_frame_num = -1;
     493         506 :     if (h->cur_pic_ptr) {
     494           0 :         h->cur_pic_ptr->reference = 0;
     495           0 :         for (j=i=0; h->delayed_pic[i]; i++)
     496           0 :             if (h->delayed_pic[i] != h->cur_pic_ptr)
     497           0 :                 h->delayed_pic[j++] = h->delayed_pic[i];
     498           0 :         h->delayed_pic[j] = NULL;
     499             :     }
     500         506 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     501             : 
     502         506 :     h->first_field = 0;
     503         506 :     h->recovery_frame = -1;
     504         506 :     h->frame_recovered = 0;
     505         506 :     h->current_slice = 0;
     506         506 :     h->mmco_reset = 1;
     507         506 : }
     508             : 
     509             : /* forget old pics after a seek */
     510           0 : static void flush_dpb(AVCodecContext *avctx)
     511             : {
     512           0 :     H264Context *h = avctx->priv_data;
     513             :     int i;
     514             : 
     515           0 :     memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
     516             : 
     517           0 :     ff_h264_flush_change(h);
     518           0 :     ff_h264_sei_uninit(&h->sei);
     519             : 
     520           0 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
     521           0 :         ff_h264_unref_picture(h, &h->DPB[i]);
     522           0 :     h->cur_pic_ptr = NULL;
     523           0 :     ff_h264_unref_picture(h, &h->cur_pic);
     524             : 
     525           0 :     h->mb_y = 0;
     526             : 
     527           0 :     ff_h264_free_tables(h);
     528           0 :     h->context_initialized = 0;
     529           0 : }
     530             : 
     531           0 : static int get_last_needed_nal(H264Context *h)
     532             : {
     533           0 :     int nals_needed = 0;
     534           0 :     int first_slice = 0;
     535             :     int i, ret;
     536             : 
     537           0 :     for (i = 0; i < h->pkt.nb_nals; i++) {
     538           0 :         H2645NAL *nal = &h->pkt.nals[i];
     539             :         GetBitContext gb;
     540             : 
     541             :         /* packets can sometimes contain multiple PPS/SPS,
     542             :          * e.g. two PAFF field pictures in one packet, or a demuxer
     543             :          * which splits NALs strangely if so, when frame threading we
     544             :          * can't start the next thread until we've read all of them */
     545           0 :         switch (nal->type) {
     546           0 :         case H264_NAL_SPS:
     547             :         case H264_NAL_PPS:
     548           0 :             nals_needed = i;
     549           0 :             break;
     550           0 :         case H264_NAL_DPA:
     551             :         case H264_NAL_IDR_SLICE:
     552             :         case H264_NAL_SLICE:
     553           0 :             ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
     554           0 :             if (ret < 0) {
     555           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
     556           0 :                 if (h->avctx->err_recognition & AV_EF_EXPLODE)
     557           0 :                     return ret;
     558             : 
     559           0 :                 break;
     560             :             }
     561           0 :             if (!get_ue_golomb_long(&gb) ||  // first_mb_in_slice
     562           0 :                 !first_slice ||
     563           0 :                 first_slice != nal->type)
     564           0 :                 nals_needed = i;
     565           0 :             if (!first_slice)
     566           0 :                 first_slice = nal->type;
     567             :         }
     568             :     }
     569             : 
     570           0 :     return nals_needed;
     571             : }
     572             : 
     573           0 : static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
     574             : {
     575           0 :     av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
     576           0 :     av_log(logctx, AV_LOG_DEBUG, "  green_metadata_type: %d\n", gm->green_metadata_type);
     577             : 
     578           0 :     if (gm->green_metadata_type == 0) {
     579           0 :         av_log(logctx, AV_LOG_DEBUG, "  green_metadata_period_type: %d\n", gm->period_type);
     580             : 
     581           0 :         if (gm->period_type == 2)
     582           0 :             av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_seconds: %d\n", gm->num_seconds);
     583           0 :         else if (gm->period_type == 3)
     584           0 :             av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_pictures: %d\n", gm->num_pictures);
     585             : 
     586           0 :         av_log(logctx, AV_LOG_DEBUG, "  SEI GREEN Complexity Metrics: %f %f %f %f\n",
     587           0 :                (float)gm->percent_non_zero_macroblocks/255,
     588           0 :                (float)gm->percent_intra_coded_macroblocks/255,
     589           0 :                (float)gm->percent_six_tap_filtering/255,
     590           0 :                (float)gm->percent_alpha_point_deblocking_instance/255);
     591             : 
     592           0 :     } else if (gm->green_metadata_type == 1) {
     593           0 :         av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_type: %d\n", gm->xsd_metric_type);
     594             : 
     595           0 :         if (gm->xsd_metric_type == 0)
     596           0 :             av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_value: %f\n",
     597           0 :                    (float)gm->xsd_metric_value/100);
     598             :     }
     599           0 : }
     600             : 
     601       25440 : static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
     602             : {
     603       25440 :     AVCodecContext *const avctx = h->avctx;
     604       25440 :     int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
     605       25440 :     int idr_cleared=0;
     606       25440 :     int i, ret = 0;
     607             : 
     608       25440 :     h->has_slice = 0;
     609       25440 :     h->nal_unit_type= 0;
     610             : 
     611       25440 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
     612       25440 :         h->current_slice = 0;
     613       25440 :         if (!h->first_field)
     614       22235 :             h->cur_pic_ptr = NULL;
     615       25440 :         ff_h264_sei_uninit(&h->sei);
     616             :     }
     617             : 
     618       25440 :     if (h->nal_length_size == 4) {
     619        2507 :         if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
     620           0 :             h->is_avc = 0;
     621        2507 :         }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
     622        2507 :             h->is_avc = 1;
     623             :     }
     624             : 
     625       25440 :     ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
     626       25440 :                                 h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);
     627       25440 :     if (ret < 0) {
     628           1 :         av_log(avctx, AV_LOG_ERROR,
     629             :                "Error splitting the input into NAL units.\n");
     630           1 :         return ret;
     631             :     }
     632             : 
     633       25439 :     if (avctx->active_thread_type & FF_THREAD_FRAME)
     634           0 :         nals_needed = get_last_needed_nal(h);
     635       25439 :     if (nals_needed < 0)
     636           0 :         return nals_needed;
     637             : 
     638       68724 :     for (i = 0; i < h->pkt.nb_nals; i++) {
     639       43285 :         H2645NAL *nal = &h->pkt.nals[i];
     640             :         int max_slice_ctx, err;
     641             : 
     642       44213 :         if (avctx->skip_frame >= AVDISCARD_NONREF &&
     643        1752 :             nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
     644         504 :             continue;
     645             : 
     646             :         // FIXME these should stop being context-global variables
     647       42781 :         h->nal_ref_idc   = nal->ref_idc;
     648       42781 :         h->nal_unit_type = nal->type;
     649             : 
     650       42781 :         err = 0;
     651       42781 :         switch (nal->type) {
     652        1969 :         case H264_NAL_IDR_SLICE:
     653        1969 :             if ((nal->data[1] & 0xFC) == 0x98) {
     654           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
     655           0 :                 h->next_outputed_poc = INT_MIN;
     656           0 :                 ret = -1;
     657           0 :                 goto end;
     658             :             }
     659        1969 :             if(!idr_cleared) {
     660         931 :                 if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {
     661           0 :                     av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");
     662           0 :                     ret = AVERROR_INVALIDDATA;
     663           0 :                     goto end;
     664             :                 }
     665         931 :                 idr(h); // FIXME ensure we don't lose some frames if there is reordering
     666             :             }
     667        1969 :             idr_cleared = 1;
     668        1969 :             h->has_recovery_point = 1;
     669       31514 :         case H264_NAL_SLICE:
     670       31514 :             h->has_slice = 1;
     671             : 
     672       31514 :             if ((err = ff_h264_queue_decode_slice(h, nal))) {
     673          23 :                 H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
     674          23 :                 sl->ref_count[0] = sl->ref_count[1] = 0;
     675          23 :                 break;
     676             :             }
     677             : 
     678       31491 :             if (h->current_slice == 1) {
     679       25098 :                 if (avctx->active_thread_type & FF_THREAD_FRAME &&
     680           0 :                     i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
     681           0 :                     ff_thread_finish_setup(avctx);
     682           0 :                     h->setup_finished = 1;
     683             :                 }
     684             : 
     685       25098 :                 if (h->avctx->hwaccel &&
     686           0 :                     (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
     687           0 :                     goto end;
     688             :             }
     689             : 
     690       31491 :             max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
     691       31491 :             if (h->nb_slice_ctx_queued == max_slice_ctx) {
     692       31410 :                 if (h->avctx->hwaccel) {
     693           0 :                     ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
     694           0 :                     h->nb_slice_ctx_queued = 0;
     695             :                 } else
     696       31410 :                     ret = ff_h264_execute_decode_slices(h);
     697       31410 :                 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     698           0 :                     goto end;
     699             :             }
     700       31491 :             break;
     701           0 :         case H264_NAL_DPA:
     702             :         case H264_NAL_DPB:
     703             :         case H264_NAL_DPC:
     704           0 :             avpriv_request_sample(avctx, "data partitioning");
     705           0 :             break;
     706        1497 :         case H264_NAL_SEI:
     707        1497 :             ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
     708        1497 :             h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;
     709        1497 :             if (avctx->debug & FF_DEBUG_GREEN_MD)
     710           0 :                 debug_green_metadata(&h->sei.green_metadata, h->avctx);
     711        1497 :             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     712           0 :                 goto end;
     713        1497 :             break;
     714         967 :         case H264_NAL_SPS: {
     715         967 :             GetBitContext tmp_gb = nal->gb;
     716         967 :             if (avctx->hwaccel && avctx->hwaccel->decode_params) {
     717           0 :                 ret = avctx->hwaccel->decode_params(avctx,
     718             :                                                     nal->type,
     719             :                                                     nal->raw_data,
     720           0 :                                                     nal->raw_size);
     721           0 :                 if (ret < 0)
     722           0 :                     goto end;
     723             :             }
     724         967 :             if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
     725        1932 :                 break;
     726           2 :             av_log(h->avctx, AV_LOG_DEBUG,
     727             :                    "SPS decoding failure, trying again with the complete NAL\n");
     728           2 :             init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
     729           2 :             if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
     730           2 :                 break;
     731           0 :             ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
     732           0 :             break;
     733             :         }
     734        6546 :         case H264_NAL_PPS:
     735        6546 :             if (avctx->hwaccel && avctx->hwaccel->decode_params) {
     736           0 :                 ret = avctx->hwaccel->decode_params(avctx,
     737             :                                                     nal->type,
     738             :                                                     nal->raw_data,
     739           0 :                                                     nal->raw_size);
     740           0 :                 if (ret < 0)
     741           0 :                     goto end;
     742             :             }
     743        6546 :             ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
     744             :                                                        nal->size_bits);
     745        6546 :             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     746           0 :                 goto end;
     747        6546 :             break;
     748        2257 :         case H264_NAL_AUD:
     749             :         case H264_NAL_END_SEQUENCE:
     750             :         case H264_NAL_END_STREAM:
     751             :         case H264_NAL_FILLER_DATA:
     752             :         case H264_NAL_SPS_EXT:
     753             :         case H264_NAL_AUXILIARY_SLICE:
     754        2257 :             break;
     755           0 :         default:
     756           0 :             av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
     757             :                    nal->type, nal->size_bits);
     758             :         }
     759             : 
     760       42781 :         if (err < 0) {
     761          23 :             av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
     762             :         }
     763             :     }
     764             : 
     765       25439 :     ret = ff_h264_execute_decode_slices(h);
     766       25439 :     if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
     767           0 :         goto end;
     768             : 
     769       25439 :     ret = 0;
     770       25439 : end:
     771             : 
     772             : #if CONFIG_ERROR_RESILIENCE
     773             :     /*
     774             :      * FIXME: Error handling code does not seem to support interlaced
     775             :      * when slices span multiple rows
     776             :      * The ff_er_add_slice calls don't work right for bottom
     777             :      * fields; they cause massive erroneous error concealing
     778             :      * Error marking covers both fields (top and bottom).
     779             :      * This causes a mismatched s->error_count
     780             :      * and a bad error table. Further, the error count goes to
     781             :      * INT_MAX when called for bottom field, because mb_y is
     782             :      * past end by one (callers fault) and resync_mb_y != 0
     783             :      * causes problems for the first MB line, too.
     784             :      */
     785       44066 :     if (!FIELD_PICTURE(h) && h->current_slice &&
     786       37254 :         h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
     787       18627 :         h->enable_er) {
     788             : 
     789       18627 :         H264SliceContext *sl = h->slice_ctx;
     790       18627 :         int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
     791             : 
     792       18627 :         ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);
     793             : 
     794       18627 :         if (use_last_pic) {
     795         436 :             ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
     796         436 :             sl->ref_list[0][0].parent = &h->last_pic_for_ec;
     797         436 :             memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
     798         436 :             memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
     799         436 :             sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
     800       18191 :         } else if (sl->ref_count[0]) {
     801       16306 :             ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
     802             :         } else
     803        1885 :             ff_h264_set_erpic(&sl->er.last_pic, NULL);
     804             : 
     805       18627 :         if (sl->ref_count[1])
     806       16306 :             ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
     807             : 
     808       18627 :         sl->er.ref_count = sl->ref_count[0];
     809             : 
     810       18627 :         ff_er_frame_end(&sl->er);
     811       18627 :         if (use_last_pic)
     812         436 :             memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
     813             :     }
     814             : #endif /* CONFIG_ERROR_RESILIENCE */
     815             :     /* clean up */
     816       25439 :     if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
     817       16094 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
     818       16094 :                                   h->picture_structure == PICT_BOTTOM_FIELD);
     819             :     }
     820             : 
     821       25439 :     return (ret < 0) ? ret : buf_size;
     822             : }
     823             : 
     824             : /**
     825             :  * Return the number of bytes consumed for building the current frame.
     826             :  */
     827       24905 : static int get_consumed_bytes(int pos, int buf_size)
     828             : {
     829       24905 :     if (pos == 0)
     830           0 :         pos = 1;        // avoid infinite loops (I doubt that is needed but...)
     831       24905 :     if (pos + 10 > buf_size)
     832       24905 :         pos = buf_size; // oops ;)
     833             : 
     834       24905 :     return pos;
     835             : }
     836             : 
     837       21358 : static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
     838             : {
     839       21358 :     AVFrame *src = srcp->f;
     840             :     int ret;
     841             : 
     842       21358 :     if (src->format == AV_PIX_FMT_VIDEOTOOLBOX && src->buf[0]->size == 1)
     843           0 :         return AVERROR_INVALIDDATA;
     844             : 
     845       21358 :     ret = av_frame_ref(dst, src);
     846       21358 :     if (ret < 0)
     847           0 :         return ret;
     848             : 
     849       21358 :     av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
     850             : 
     851       21358 :     if (srcp->sei_recovery_frame_cnt == 0)
     852          23 :         dst->key_frame = 1;
     853             : 
     854       21358 :     return 0;
     855             : }
     856             : 
     857           4 : static int is_extra(const uint8_t *buf, int buf_size)
     858             : {
     859           4 :     int cnt= buf[5]&0x1f;
     860           4 :     const uint8_t *p= buf+6;
     861          12 :     while(cnt--){
     862           4 :         int nalsize= AV_RB16(p) + 2;
     863           4 :         if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
     864           0 :             return 0;
     865           4 :         p += nalsize;
     866             :     }
     867           4 :     cnt = *(p++);
     868           4 :     if(!cnt)
     869           0 :         return 0;
     870          12 :     while(cnt--){
     871           4 :         int nalsize= AV_RB16(p) + 2;
     872           4 :         if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
     873           0 :             return 0;
     874           4 :         p += nalsize;
     875             :     }
     876           4 :     return 1;
     877             : }
     878             : 
     879       21358 : static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
     880             : {
     881             :     int ret;
     882             : 
     883       42716 :     if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
     884       42716 :          (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
     885       21358 :          out->recovered)) {
     886             : 
     887       42716 :         if (!h->avctx->hwaccel &&
     888       42716 :             (out->field_poc[0] == INT_MAX ||
     889       21358 :              out->field_poc[1] == INT_MAX)
     890             :            ) {
     891             :             int p;
     892           0 :             AVFrame *f = out->f;
     893           0 :             int field = out->field_poc[0] == INT_MAX;
     894             :             uint8_t *dst_data[4];
     895             :             int linesizes[4];
     896             :             const uint8_t *src_data[4];
     897             : 
     898           0 :             av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
     899             : 
     900           0 :             for (p = 0; p<4; p++) {
     901           0 :                 dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
     902           0 :                 src_data[p] = f->data[p] +  field   *f->linesize[p];
     903           0 :                 linesizes[p] = 2*f->linesize[p];
     904             :             }
     905             : 
     906           0 :             av_image_copy(dst_data, linesizes, src_data, linesizes,
     907           0 :                           f->format, f->width, f->height>>1);
     908             :         }
     909             : 
     910       21358 :         ret = output_frame(h, dst, out);
     911       21358 :         if (ret < 0)
     912           0 :             return ret;
     913             : 
     914       21358 :         *got_frame = 1;
     915             : 
     916             :         if (CONFIG_MPEGVIDEO) {
     917       42716 :             ff_print_debug_info2(h->avctx, dst, NULL,
     918             :                                  out->mb_type,
     919             :                                  out->qscale_table,
     920       21358 :                                  out->motion_val,
     921             :                                  NULL,
     922             :                                  h->mb_width, h->mb_height, h->mb_stride, 1);
     923             :         }
     924             :     }
     925             : 
     926       21358 :     return 0;
     927             : }
     928             : 
     929         441 : static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame,
     930             :                                    int *got_frame, int buf_index)
     931             : {
     932             :     int ret, i, out_idx;
     933         441 :     H264Picture *out = h->delayed_pic[0];
     934             : 
     935         441 :     h->cur_pic_ptr = NULL;
     936         441 :     h->first_field = 0;
     937             : 
     938         441 :     out_idx = 0;
     939        1068 :     for (i = 1;
     940         813 :          h->delayed_pic[i] &&
     941         372 :          !h->delayed_pic[i]->f->key_frame &&
     942         186 :          !h->delayed_pic[i]->mmco_reset;
     943         186 :          i++)
     944         186 :         if (h->delayed_pic[i]->poc < out->poc) {
     945          63 :             out     = h->delayed_pic[i];
     946          63 :             out_idx = i;
     947             :         }
     948             : 
     949         744 :     for (i = out_idx; h->delayed_pic[i]; i++)
     950         303 :         h->delayed_pic[i] = h->delayed_pic[i + 1];
     951             : 
     952         441 :     if (out) {
     953         200 :         out->reference &= ~DELAYED_PIC_REF;
     954         200 :         ret = finalize_frame(h, dst_frame, out, got_frame);
     955         200 :         if (ret < 0)
     956           0 :             return ret;
     957             :     }
     958             : 
     959         441 :     return buf_index;
     960             : }
     961             : 
     962       25881 : static int h264_decode_frame(AVCodecContext *avctx, void *data,
     963             :                              int *got_frame, AVPacket *avpkt)
     964             : {
     965       25881 :     const uint8_t *buf = avpkt->data;
     966       25881 :     int buf_size       = avpkt->size;
     967       25881 :     H264Context *h     = avctx->priv_data;
     968       25881 :     AVFrame *pict      = data;
     969             :     int buf_index;
     970             :     int ret;
     971             : 
     972       25881 :     h->flags = avctx->flags;
     973       25881 :     h->setup_finished = 0;
     974       25881 :     h->nb_slice_ctx_queued = 0;
     975             : 
     976       25881 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
     977             : 
     978             :     /* end of stream, output what is still in the buffers */
     979       25881 :     if (buf_size == 0)
     980         441 :         return send_next_delayed_frame(h, pict, got_frame, 0);
     981             : 
     982       25440 :     if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
     983             :         int side_size;
     984           4 :         uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
     985           4 :         if (is_extra(side, side_size))
     986           4 :             ff_h264_decode_extradata(side, side_size,
     987             :                                      &h->ps, &h->is_avc, &h->nal_length_size,
     988             :                                      avctx->err_recognition, avctx);
     989             :     }
     990       25440 :     if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){
     991           0 :         if (is_extra(buf, buf_size))
     992           0 :             return ff_h264_decode_extradata(buf, buf_size,
     993             :                                             &h->ps, &h->is_avc, &h->nal_length_size,
     994             :                                             avctx->err_recognition, avctx);
     995             :     }
     996             : 
     997       25440 :     buf_index = decode_nal_units(h, buf, buf_size);
     998       25440 :     if (buf_index < 0)
     999           1 :         return AVERROR_INVALIDDATA;
    1000             : 
    1001       25439 :     if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {
    1002           0 :         av_assert0(buf_index <= buf_size);
    1003           0 :         return send_next_delayed_frame(h, pict, got_frame, buf_index);
    1004             :     }
    1005             : 
    1006       25439 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
    1007         534 :         if (avctx->skip_frame >= AVDISCARD_NONREF ||
    1008         334 :             buf_size >= 4 && !memcmp("Q264", buf, 4))
    1009         200 :             return buf_size;
    1010         334 :         av_log(avctx, AV_LOG_ERROR, "no frame!\n");
    1011         334 :         return AVERROR_INVALIDDATA;
    1012             :     }
    1013             : 
    1014       24905 :     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
    1015           0 :         (h->mb_y >= h->mb_height && h->mb_height)) {
    1016       24905 :         if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
    1017           0 :             return ret;
    1018             : 
    1019             :         /* Wait for second field. */
    1020       24905 :         if (h->next_output_pic) {
    1021       21158 :             ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
    1022       21158 :             if (ret < 0)
    1023           0 :                 return ret;
    1024             :         }
    1025             :     }
    1026             : 
    1027       24905 :     av_assert0(pict->buf[0] || !*got_frame);
    1028             : 
    1029       24905 :     ff_h264_unref_picture(h, &h->last_pic_for_ec);
    1030             : 
    1031       24905 :     return get_consumed_bytes(buf_index, buf_size);
    1032             : }
    1033             : 
    1034             : #define OFFSET(x) offsetof(H264Context, x)
    1035             : #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
    1036             : static const AVOption h264_options[] = {
    1037             :     { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
    1038             :     { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
    1039             :     { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, 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