LCOV - code coverage report
Current view: top level - libavcodec - h264_slice.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1208 1663 72.6 %
Date: 2017-12-14 08:27:08 Functions: 28 31 90.3 %

          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             : #include "libavutil/avassert.h"
      29             : #include "libavutil/display.h"
      30             : #include "libavutil/imgutils.h"
      31             : #include "libavutil/stereo3d.h"
      32             : #include "libavutil/timer.h"
      33             : #include "internal.h"
      34             : #include "cabac.h"
      35             : #include "cabac_functions.h"
      36             : #include "error_resilience.h"
      37             : #include "avcodec.h"
      38             : #include "h264.h"
      39             : #include "h264dec.h"
      40             : #include "h264data.h"
      41             : #include "h264chroma.h"
      42             : #include "h264_mvpred.h"
      43             : #include "h264_ps.h"
      44             : #include "golomb.h"
      45             : #include "mathops.h"
      46             : #include "mpegutils.h"
      47             : #include "mpegvideo.h"
      48             : #include "rectangle.h"
      49             : #include "thread.h"
      50             : 
      51             : static const uint8_t field_scan[16+1] = {
      52             :     0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
      53             :     0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
      54             :     2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
      55             :     3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
      56             : };
      57             : 
      58             : static const uint8_t field_scan8x8[64+1] = {
      59             :     0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
      60             :     1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
      61             :     2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
      62             :     0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
      63             :     2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
      64             :     2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
      65             :     2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
      66             :     3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
      67             :     3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
      68             :     4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
      69             :     4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
      70             :     5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
      71             :     5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
      72             :     7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
      73             :     6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
      74             :     7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
      75             : };
      76             : 
      77             : static const uint8_t field_scan8x8_cavlc[64+1] = {
      78             :     0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
      79             :     2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
      80             :     3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
      81             :     5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
      82             :     0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
      83             :     1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
      84             :     3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
      85             :     5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
      86             :     0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
      87             :     1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
      88             :     3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
      89             :     5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
      90             :     1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
      91             :     1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
      92             :     3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
      93             :     6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
      94             : };
      95             : 
      96             : // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
      97             : static const uint8_t zigzag_scan8x8_cavlc[64+1] = {
      98             :     0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
      99             :     4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
     100             :     3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
     101             :     2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
     102             :     1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
     103             :     3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
     104             :     2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
     105             :     3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
     106             :     0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
     107             :     2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
     108             :     1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
     109             :     4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
     110             :     0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
     111             :     1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
     112             :     0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
     113             :     5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
     114             : };
     115             : 
     116       25724 : static void release_unused_pictures(H264Context *h, int remove_current)
     117             : {
     118             :     int i;
     119             : 
     120             :     /* release non reference frames */
     121      951788 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     122      926064 :         if (h->DPB[i].f->buf[0] && !h->DPB[i].reference &&
     123        2480 :             (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {
     124       20579 :             ff_h264_unref_picture(h, &h->DPB[i]);
     125             :         }
     126             :     }
     127       25724 : }
     128             : 
     129       31410 : static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
     130             : {
     131       31410 :     const H264Context *h = sl->h264;
     132       31410 :     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
     133             : 
     134       31410 :     av_fast_malloc(&sl->bipred_scratchpad, &sl->bipred_scratchpad_allocated, 16 * 6 * alloc_size);
     135             :     // edge emu needs blocksize + filter length - 1
     136             :     // (= 21x21 for  H.264)
     137       31410 :     av_fast_malloc(&sl->edge_emu_buffer, &sl->edge_emu_buffer_allocated, alloc_size * 2 * 21);
     138             : 
     139       31410 :     av_fast_mallocz(&sl->top_borders[0], &sl->top_borders_allocated[0],
     140       31410 :                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
     141       31410 :     av_fast_mallocz(&sl->top_borders[1], &sl->top_borders_allocated[1],
     142       31410 :                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
     143             : 
     144       62820 :     if (!sl->bipred_scratchpad || !sl->edge_emu_buffer ||
     145       62820 :         !sl->top_borders[0]    || !sl->top_borders[1]) {
     146           0 :         av_freep(&sl->bipred_scratchpad);
     147           0 :         av_freep(&sl->edge_emu_buffer);
     148           0 :         av_freep(&sl->top_borders[0]);
     149           0 :         av_freep(&sl->top_borders[1]);
     150             : 
     151           0 :         sl->bipred_scratchpad_allocated = 0;
     152           0 :         sl->edge_emu_buffer_allocated   = 0;
     153           0 :         sl->top_borders_allocated[0]    = 0;
     154           0 :         sl->top_borders_allocated[1]    = 0;
     155           0 :         return AVERROR(ENOMEM);
     156             :     }
     157             : 
     158       31410 :     return 0;
     159             : }
     160             : 
     161         502 : static int init_table_pools(H264Context *h)
     162             : {
     163         502 :     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
     164         502 :     const int mb_array_size = h->mb_stride * h->mb_height;
     165         502 :     const int b4_stride     = h->mb_width * 4 + 1;
     166         502 :     const int b4_array_size = b4_stride * h->mb_height * 4;
     167             : 
     168         502 :     h->qscale_table_pool = av_buffer_pool_init(big_mb_num + h->mb_stride,
     169             :                                                av_buffer_allocz);
     170         502 :     h->mb_type_pool      = av_buffer_pool_init((big_mb_num + h->mb_stride) *
     171             :                                                sizeof(uint32_t), av_buffer_allocz);
     172         502 :     h->motion_val_pool   = av_buffer_pool_init(2 * (b4_array_size + 4) *
     173             :                                                sizeof(int16_t), av_buffer_allocz);
     174         502 :     h->ref_index_pool    = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz);
     175             : 
     176        1004 :     if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
     177         502 :         !h->ref_index_pool) {
     178           0 :         av_buffer_pool_uninit(&h->qscale_table_pool);
     179           0 :         av_buffer_pool_uninit(&h->mb_type_pool);
     180           0 :         av_buffer_pool_uninit(&h->motion_val_pool);
     181           0 :         av_buffer_pool_uninit(&h->ref_index_pool);
     182           0 :         return AVERROR(ENOMEM);
     183             :     }
     184             : 
     185         502 :     return 0;
     186             : }
     187             : 
     188       22490 : static int alloc_picture(H264Context *h, H264Picture *pic)
     189             : {
     190       22490 :     int i, ret = 0;
     191             : 
     192       22490 :     av_assert0(!pic->f->data[0]);
     193             : 
     194       22490 :     pic->tf.f = pic->f;
     195       22490 :     ret = ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ?
     196             :                                                    AV_GET_BUFFER_FLAG_REF : 0);
     197       22490 :     if (ret < 0)
     198           0 :         goto fail;
     199             : 
     200       22490 :     if (h->avctx->hwaccel) {
     201           0 :         const AVHWAccel *hwaccel = h->avctx->hwaccel;
     202           0 :         av_assert0(!pic->hwaccel_picture_private);
     203           0 :         if (hwaccel->frame_priv_data_size) {
     204           0 :             pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
     205           0 :             if (!pic->hwaccel_priv_buf)
     206           0 :                 return AVERROR(ENOMEM);
     207           0 :             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
     208             :         }
     209             :     }
     210             :     if (CONFIG_GRAY && !h->avctx->hwaccel && h->flags & AV_CODEC_FLAG_GRAY && pic->f->data[2]) {
     211             :         int h_chroma_shift, v_chroma_shift;
     212             :         av_pix_fmt_get_chroma_sub_sample(pic->f->format,
     213             :                                          &h_chroma_shift, &v_chroma_shift);
     214             : 
     215             :         for(i=0; i<AV_CEIL_RSHIFT(pic->f->height, v_chroma_shift); i++) {
     216             :             memset(pic->f->data[1] + pic->f->linesize[1]*i,
     217             :                    0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
     218             :             memset(pic->f->data[2] + pic->f->linesize[2]*i,
     219             :                    0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
     220             :         }
     221             :     }
     222             : 
     223       22490 :     if (!h->qscale_table_pool) {
     224         502 :         ret = init_table_pools(h);
     225         502 :         if (ret < 0)
     226           0 :             goto fail;
     227             :     }
     228             : 
     229       22490 :     pic->qscale_table_buf = av_buffer_pool_get(h->qscale_table_pool);
     230       22490 :     pic->mb_type_buf      = av_buffer_pool_get(h->mb_type_pool);
     231       22490 :     if (!pic->qscale_table_buf || !pic->mb_type_buf)
     232             :         goto fail;
     233             : 
     234       22490 :     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
     235       22490 :     pic->qscale_table = pic->qscale_table_buf->data + 2 * h->mb_stride + 1;
     236             : 
     237       67470 :     for (i = 0; i < 2; i++) {
     238       44980 :         pic->motion_val_buf[i] = av_buffer_pool_get(h->motion_val_pool);
     239       44980 :         pic->ref_index_buf[i]  = av_buffer_pool_get(h->ref_index_pool);
     240       89960 :         if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
     241             :             goto fail;
     242             : 
     243       44980 :         pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
     244       44980 :         pic->ref_index[i]  = pic->ref_index_buf[i]->data;
     245             :     }
     246             : 
     247       22490 :     return 0;
     248           0 : fail:
     249           0 :     ff_h264_unref_picture(h, pic);
     250           0 :     return (ret < 0) ? ret : AVERROR(ENOMEM);
     251             : }
     252             : 
     253       22490 : static int find_unused_picture(H264Context *h)
     254             : {
     255             :     int i;
     256             : 
     257       78423 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     258       78423 :         if (!h->DPB[i].f->buf[0])
     259       22490 :             return i;
     260             :     }
     261           0 :     return AVERROR_INVALIDDATA;
     262             : }
     263             : 
     264             : 
     265             : #define IN_RANGE(a, b, size) (((void*)(a) >= (void*)(b)) && ((void*)(a) < (void*)((b) + (size))))
     266             : 
     267             : #define REBASE_PICTURE(pic, new_ctx, old_ctx)             \
     268             :     (((pic) && (pic) >= (old_ctx)->DPB &&                       \
     269             :       (pic) < (old_ctx)->DPB + H264_MAX_PICTURE_COUNT) ?          \
     270             :      &(new_ctx)->DPB[(pic) - (old_ctx)->DPB] : NULL)
     271             : 
     272           0 : static void copy_picture_range(H264Picture **to, H264Picture **from, int count,
     273             :                                H264Context *new_base,
     274             :                                H264Context *old_base)
     275             : {
     276             :     int i;
     277             : 
     278           0 :     for (i = 0; i < count; i++) {
     279             :         av_assert1(!from[i] ||
     280             :                    IN_RANGE(from[i], old_base, 1) ||
     281             :                    IN_RANGE(from[i], old_base->DPB, H264_MAX_PICTURE_COUNT));
     282           0 :         to[i] = REBASE_PICTURE(from[i], new_base, old_base);
     283             :     }
     284           0 : }
     285             : 
     286             : static int h264_slice_header_init(H264Context *h);
     287             : 
     288           0 : int ff_h264_update_thread_context(AVCodecContext *dst,
     289             :                                   const AVCodecContext *src)
     290             : {
     291           0 :     H264Context *h = dst->priv_data, *h1 = src->priv_data;
     292           0 :     int inited = h->context_initialized, err = 0;
     293           0 :     int need_reinit = 0;
     294             :     int i, ret;
     295             : 
     296           0 :     if (dst == src)
     297           0 :         return 0;
     298             : 
     299             :     // We can't fail if SPS isn't set at it breaks current skip_frame code
     300             :     //if (!h1->ps.sps)
     301             :     //    return AVERROR_INVALIDDATA;
     302             : 
     303           0 :     if (inited &&
     304           0 :         (h->width                 != h1->width                 ||
     305           0 :          h->height                != h1->height                ||
     306           0 :          h->mb_width              != h1->mb_width              ||
     307           0 :          h->mb_height             != h1->mb_height             ||
     308           0 :          !h->ps.sps                                            ||
     309           0 :          h->ps.sps->bit_depth_luma    != h1->ps.sps->bit_depth_luma    ||
     310           0 :          h->ps.sps->chroma_format_idc != h1->ps.sps->chroma_format_idc ||
     311           0 :          h->ps.sps->colorspace        != h1->ps.sps->colorspace)) {
     312           0 :         need_reinit = 1;
     313             :     }
     314             : 
     315             :     /* copy block_offset since frame_start may not be called */
     316           0 :     memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
     317             : 
     318             :     // SPS/PPS
     319           0 :     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++) {
     320           0 :         av_buffer_unref(&h->ps.sps_list[i]);
     321           0 :         if (h1->ps.sps_list[i]) {
     322           0 :             h->ps.sps_list[i] = av_buffer_ref(h1->ps.sps_list[i]);
     323           0 :             if (!h->ps.sps_list[i])
     324           0 :                 return AVERROR(ENOMEM);
     325             :         }
     326             :     }
     327           0 :     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
     328           0 :         av_buffer_unref(&h->ps.pps_list[i]);
     329           0 :         if (h1->ps.pps_list[i]) {
     330           0 :             h->ps.pps_list[i] = av_buffer_ref(h1->ps.pps_list[i]);
     331           0 :             if (!h->ps.pps_list[i])
     332           0 :                 return AVERROR(ENOMEM);
     333             :         }
     334             :     }
     335             : 
     336           0 :     av_buffer_unref(&h->ps.pps_ref);
     337           0 :     av_buffer_unref(&h->ps.sps_ref);
     338           0 :     h->ps.pps = NULL;
     339           0 :     h->ps.sps = NULL;
     340           0 :     if (h1->ps.pps_ref) {
     341           0 :         h->ps.pps_ref = av_buffer_ref(h1->ps.pps_ref);
     342           0 :         if (!h->ps.pps_ref)
     343           0 :             return AVERROR(ENOMEM);
     344           0 :         h->ps.pps = (const PPS*)h->ps.pps_ref->data;
     345             :     }
     346           0 :     if (h1->ps.sps_ref) {
     347           0 :         h->ps.sps_ref = av_buffer_ref(h1->ps.sps_ref);
     348           0 :         if (!h->ps.sps_ref)
     349           0 :             return AVERROR(ENOMEM);
     350           0 :         h->ps.sps = (const SPS*)h->ps.sps_ref->data;
     351             :     }
     352             : 
     353           0 :     if (need_reinit || !inited) {
     354           0 :         h->width     = h1->width;
     355           0 :         h->height    = h1->height;
     356           0 :         h->mb_height = h1->mb_height;
     357           0 :         h->mb_width  = h1->mb_width;
     358           0 :         h->mb_num    = h1->mb_num;
     359           0 :         h->mb_stride = h1->mb_stride;
     360           0 :         h->b_stride  = h1->b_stride;
     361             : 
     362           0 :         if (h->context_initialized || h1->context_initialized) {
     363           0 :             if ((err = h264_slice_header_init(h)) < 0) {
     364           0 :                 av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
     365           0 :                 return err;
     366             :             }
     367             :         }
     368             : 
     369             :         /* copy block_offset since frame_start may not be called */
     370           0 :         memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
     371             :     }
     372             : 
     373           0 :     h->avctx->coded_height  = h1->avctx->coded_height;
     374           0 :     h->avctx->coded_width   = h1->avctx->coded_width;
     375           0 :     h->avctx->width         = h1->avctx->width;
     376           0 :     h->avctx->height        = h1->avctx->height;
     377           0 :     h->width_from_caller    = h1->width_from_caller;
     378           0 :     h->height_from_caller   = h1->height_from_caller;
     379           0 :     h->coded_picture_number = h1->coded_picture_number;
     380           0 :     h->first_field          = h1->first_field;
     381           0 :     h->picture_structure    = h1->picture_structure;
     382           0 :     h->mb_aff_frame         = h1->mb_aff_frame;
     383           0 :     h->droppable            = h1->droppable;
     384             : 
     385           0 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     386           0 :         ff_h264_unref_picture(h, &h->DPB[i]);
     387           0 :         if (h1->DPB[i].f->buf[0] &&
     388           0 :             (ret = ff_h264_ref_picture(h, &h->DPB[i], &h1->DPB[i])) < 0)
     389           0 :             return ret;
     390             :     }
     391             : 
     392           0 :     h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
     393           0 :     ff_h264_unref_picture(h, &h->cur_pic);
     394           0 :     if (h1->cur_pic.f->buf[0]) {
     395           0 :         ret = ff_h264_ref_picture(h, &h->cur_pic, &h1->cur_pic);
     396           0 :         if (ret < 0)
     397           0 :             return ret;
     398             :     }
     399             : 
     400           0 :     h->enable_er       = h1->enable_er;
     401           0 :     h->workaround_bugs = h1->workaround_bugs;
     402           0 :     h->x264_build      = h1->x264_build;
     403           0 :     h->droppable       = h1->droppable;
     404             : 
     405             :     // extradata/NAL handling
     406           0 :     h->is_avc = h1->is_avc;
     407           0 :     h->nal_length_size = h1->nal_length_size;
     408             : 
     409           0 :     memcpy(&h->poc,        &h1->poc,        sizeof(h->poc));
     410             : 
     411           0 :     memcpy(h->short_ref,   h1->short_ref,   sizeof(h->short_ref));
     412           0 :     memcpy(h->long_ref,    h1->long_ref,    sizeof(h->long_ref));
     413           0 :     memcpy(h->delayed_pic, h1->delayed_pic, sizeof(h->delayed_pic));
     414           0 :     memcpy(h->last_pocs,   h1->last_pocs,   sizeof(h->last_pocs));
     415             : 
     416           0 :     h->next_output_pic   = h1->next_output_pic;
     417           0 :     h->next_outputed_poc = h1->next_outputed_poc;
     418             : 
     419           0 :     memcpy(h->mmco, h1->mmco, sizeof(h->mmco));
     420           0 :     h->nb_mmco         = h1->nb_mmco;
     421           0 :     h->mmco_reset      = h1->mmco_reset;
     422           0 :     h->explicit_ref_marking = h1->explicit_ref_marking;
     423           0 :     h->long_ref_count  = h1->long_ref_count;
     424           0 :     h->short_ref_count = h1->short_ref_count;
     425             : 
     426           0 :     copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
     427           0 :     copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
     428           0 :     copy_picture_range(h->delayed_pic, h1->delayed_pic,
     429             :                        MAX_DELAYED_PIC_COUNT + 2, h, h1);
     430             : 
     431           0 :     h->frame_recovered       = h1->frame_recovered;
     432             : 
     433           0 :     if (!h->cur_pic_ptr)
     434           0 :         return 0;
     435             : 
     436           0 :     if (!h->droppable) {
     437           0 :         err = ff_h264_execute_ref_pic_marking(h);
     438           0 :         h->poc.prev_poc_msb = h->poc.poc_msb;
     439           0 :         h->poc.prev_poc_lsb = h->poc.poc_lsb;
     440             :     }
     441           0 :     h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
     442           0 :     h->poc.prev_frame_num        = h->poc.frame_num;
     443             : 
     444           0 :     h->recovery_frame        = h1->recovery_frame;
     445             : 
     446           0 :     return err;
     447             : }
     448             : 
     449       22490 : static int h264_frame_start(H264Context *h)
     450             : {
     451             :     H264Picture *pic;
     452             :     int i, ret;
     453       22490 :     const int pixel_shift = h->pixel_shift;
     454       67470 :     int c[4] = {
     455       22490 :         1<<(h->ps.sps->bit_depth_luma-1),
     456       22490 :         1<<(h->ps.sps->bit_depth_chroma-1),
     457       22490 :         1<<(h->ps.sps->bit_depth_chroma-1),
     458             :         -1
     459             :     };
     460             : 
     461       22490 :     if (!ff_thread_can_start_frame(h->avctx)) {
     462           0 :         av_log(h->avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
     463           0 :         return -1;
     464             :     }
     465             : 
     466       22490 :     release_unused_pictures(h, 1);
     467       22490 :     h->cur_pic_ptr = NULL;
     468             : 
     469       22490 :     i = find_unused_picture(h);
     470       22490 :     if (i < 0) {
     471           0 :         av_log(h->avctx, AV_LOG_ERROR, "no frame buffer available\n");
     472           0 :         return i;
     473             :     }
     474       22490 :     pic = &h->DPB[i];
     475             : 
     476       22490 :     pic->reference              = h->droppable ? 0 : h->picture_structure;
     477       22490 :     pic->f->coded_picture_number = h->coded_picture_number++;
     478       22490 :     pic->field_picture          = h->picture_structure != PICT_FRAME;
     479       22490 :     pic->frame_num               = h->poc.frame_num;
     480             :     /*
     481             :      * Zero key_frame here; IDR markings per slice in frame or fields are ORed
     482             :      * in later.
     483             :      * See decode_nal_units().
     484             :      */
     485       22490 :     pic->f->key_frame = 0;
     486       22490 :     pic->mmco_reset  = 0;
     487       22490 :     pic->recovered   = 0;
     488       22490 :     pic->invalid_gap = 0;
     489       22490 :     pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
     490             : 
     491       22490 :     pic->f->pict_type = h->slice_ctx[0].slice_type;
     492             : 
     493       22490 :     pic->f->crop_left   = h->crop_left;
     494       22490 :     pic->f->crop_right  = h->crop_right;
     495       22490 :     pic->f->crop_top    = h->crop_top;
     496       22490 :     pic->f->crop_bottom = h->crop_bottom;
     497             : 
     498       22490 :     if ((ret = alloc_picture(h, pic)) < 0)
     499           0 :         return ret;
     500       22490 :     if(!h->frame_recovered && !h->avctx->hwaccel)
     501         605 :         ff_color_frame(pic->f, c);
     502             : 
     503       22490 :     h->cur_pic_ptr = pic;
     504       22490 :     ff_h264_unref_picture(h, &h->cur_pic);
     505             :     if (CONFIG_ERROR_RESILIENCE) {
     506       22490 :         ff_h264_set_erpic(&h->slice_ctx[0].er.cur_pic, NULL);
     507             :     }
     508             : 
     509       22490 :     if ((ret = ff_h264_ref_picture(h, &h->cur_pic, h->cur_pic_ptr)) < 0)
     510           0 :         return ret;
     511             : 
     512       44980 :     for (i = 0; i < h->nb_slice_ctx; i++) {
     513       22490 :         h->slice_ctx[i].linesize   = h->cur_pic_ptr->f->linesize[0];
     514       22490 :         h->slice_ctx[i].uvlinesize = h->cur_pic_ptr->f->linesize[1];
     515             :     }
     516             : 
     517       22490 :     if (CONFIG_ERROR_RESILIENCE && h->enable_er) {
     518       22490 :         ff_er_frame_start(&h->slice_ctx[0].er);
     519       22490 :         ff_h264_set_erpic(&h->slice_ctx[0].er.last_pic, NULL);
     520       22490 :         ff_h264_set_erpic(&h->slice_ctx[0].er.next_pic, NULL);
     521             :     }
     522             : 
     523      382330 :     for (i = 0; i < 16; i++) {
     524      359840 :         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
     525      359840 :         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
     526             :     }
     527      382330 :     for (i = 0; i < 16; i++) {
     528      719680 :         h->block_offset[16 + i]      =
     529      719680 :         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
     530      719680 :         h->block_offset[48 + 16 + i] =
     531      719680 :         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
     532             :     }
     533             : 
     534             :     /* We mark the current picture as non-reference after allocating it, so
     535             :      * that if we break out due to an error it can be released automatically
     536             :      * in the next ff_mpv_frame_start().
     537             :      */
     538       22490 :     h->cur_pic_ptr->reference = 0;
     539             : 
     540       22490 :     h->cur_pic_ptr->field_poc[0] = h->cur_pic_ptr->field_poc[1] = INT_MAX;
     541             : 
     542       22490 :     h->next_output_pic = NULL;
     543             : 
     544       22490 :     h->postpone_filter = 0;
     545             : 
     546       22490 :     h->mb_aff_frame = h->ps.sps->mb_aff && (h->picture_structure == PICT_FRAME);
     547             : 
     548       22490 :     if (h->sei.unregistered.x264_build >= 0)
     549        1215 :         h->x264_build = h->sei.unregistered.x264_build;
     550             : 
     551             :     assert(h->cur_pic_ptr->long_ref == 0);
     552             : 
     553       22490 :     return 0;
     554             : }
     555             : 
     556    10343344 : static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
     557             :                                               uint8_t *src_y,
     558             :                                               uint8_t *src_cb, uint8_t *src_cr,
     559             :                                               int linesize, int uvlinesize,
     560             :                                               int simple)
     561             : {
     562             :     uint8_t *top_border;
     563    10343344 :     int top_idx = 1;
     564    10343344 :     const int pixel_shift = h->pixel_shift;
     565    10343344 :     int chroma444 = CHROMA444(h);
     566    10343344 :     int chroma422 = CHROMA422(h);
     567             : 
     568    10343344 :     src_y  -= linesize;
     569    10343344 :     src_cb -= uvlinesize;
     570    10343344 :     src_cr -= uvlinesize;
     571             : 
     572    10343344 :     if (!simple && FRAME_MBAFF(h)) {
     573     1576140 :         if (sl->mb_y & 1) {
     574      788070 :             if (!MB_MBAFF(sl)) {
     575      546813 :                 top_border = sl->top_borders[0][sl->mb_x];
     576      546813 :                 AV_COPY128(top_border, src_y + 15 * linesize);
     577      546813 :                 if (pixel_shift)
     578      213139 :                     AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
     579             :                 if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     580      546813 :                     if (chroma444) {
     581           0 :                         if (pixel_shift) {
     582           0 :                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
     583           0 :                             AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
     584           0 :                             AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
     585           0 :                             AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
     586             :                         } else {
     587           0 :                             AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
     588           0 :                             AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
     589             :                         }
     590      546813 :                     } else if (chroma422) {
     591      106510 :                         if (pixel_shift) {
     592      106510 :                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
     593      106510 :                             AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
     594             :                         } else {
     595           0 :                             AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
     596           0 :                             AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
     597             :                         }
     598             :                     } else {
     599      440303 :                         if (pixel_shift) {
     600      106629 :                             AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
     601      106629 :                             AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
     602             :                         } else {
     603      333674 :                             AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
     604      333674 :                             AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
     605             :                         }
     606             :                     }
     607             :                 }
     608             :             }
     609      788070 :         } else if (MB_MBAFF(sl)) {
     610      241257 :             top_idx = 0;
     611             :         } else
     612      546813 :             return;
     613             :     }
     614             : 
     615     9796531 :     top_border = sl->top_borders[top_idx][sl->mb_x];
     616             :     /* There are two lines saved, the line above the top macroblock
     617             :      * of a pair, and the line above the bottom macroblock. */
     618     9796531 :     AV_COPY128(top_border, src_y + 16 * linesize);
     619     9796531 :     if (pixel_shift)
     620     1300901 :         AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
     621             : 
     622             :     if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     623     9796531 :         if (chroma444) {
     624       36120 :             if (pixel_shift) {
     625       19800 :                 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
     626       19800 :                 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
     627       19800 :                 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
     628       19800 :                 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
     629             :             } else {
     630       16320 :                 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
     631       16320 :                 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
     632             :             }
     633     9760411 :         } else if (chroma422) {
     634      588635 :             if (pixel_shift) {
     635      584675 :                 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
     636      584675 :                 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
     637             :             } else {
     638        3960 :                 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
     639        3960 :                 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
     640             :             }
     641             :         } else {
     642     9171776 :             if (pixel_shift) {
     643      696426 :                 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
     644      696426 :                 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
     645             :             } else {
     646     8475350 :                 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
     647     8475350 :                 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
     648             :             }
     649             :         }
     650             :     }
     651             : }
     652             : 
     653             : /**
     654             :  * Initialize implicit_weight table.
     655             :  * @param field  0/1 initialize the weight for interlaced MBAFF
     656             :  *                -1 initializes the rest
     657             :  */
     658         754 : static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
     659             : {
     660             :     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
     661             : 
     662        2262 :     for (i = 0; i < 2; i++) {
     663        1508 :         sl->pwt.luma_weight_flag[i]   = 0;
     664        1508 :         sl->pwt.chroma_weight_flag[i] = 0;
     665             :     }
     666             : 
     667         754 :     if (field < 0) {
     668         732 :         if (h->picture_structure == PICT_FRAME) {
     669         732 :             cur_poc = h->cur_pic_ptr->poc;
     670             :         } else {
     671           0 :             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
     672             :         }
     673         827 :         if (sl->ref_count[0] == 1 && sl->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
     674          95 :             sl->ref_list[0][0].poc + (int64_t)sl->ref_list[1][0].poc == 2 * cur_poc) {
     675          33 :             sl->pwt.use_weight        = 0;
     676          33 :             sl->pwt.use_weight_chroma = 0;
     677          33 :             return;
     678             :         }
     679         699 :         ref_start  = 0;
     680         699 :         ref_count0 = sl->ref_count[0];
     681         699 :         ref_count1 = sl->ref_count[1];
     682             :     } else {
     683          22 :         cur_poc    = h->cur_pic_ptr->field_poc[field];
     684          22 :         ref_start  = 16;
     685          22 :         ref_count0 = 16 + 2 * sl->ref_count[0];
     686          22 :         ref_count1 = 16 + 2 * sl->ref_count[1];
     687             :     }
     688             : 
     689         721 :     sl->pwt.use_weight               = 2;
     690         721 :     sl->pwt.use_weight_chroma        = 2;
     691         721 :     sl->pwt.luma_log2_weight_denom   = 5;
     692         721 :     sl->pwt.chroma_log2_weight_denom = 5;
     693             : 
     694        3772 :     for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
     695        3051 :         int64_t poc0 = sl->ref_list[0][ref0].poc;
     696        7124 :         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
     697        4073 :             int w = 32;
     698        4073 :             if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
     699        4073 :                 int poc1 = sl->ref_list[1][ref1].poc;
     700        4073 :                 int td   = av_clip_int8(poc1 - poc0);
     701        4073 :                 if (td) {
     702        4007 :                     int tb = av_clip_int8(cur_poc - poc0);
     703        4007 :                     int tx = (16384 + (FFABS(td) >> 1)) / td;
     704        4007 :                     int dist_scale_factor = (tb * tx + 32) >> 8;
     705        4007 :                     if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
     706        4004 :                         w = 64 - dist_scale_factor;
     707             :                 }
     708             :             }
     709        4073 :             if (field < 0) {
     710        3841 :                 sl->pwt.implicit_weight[ref0][ref1][0] =
     711        3841 :                 sl->pwt.implicit_weight[ref0][ref1][1] = w;
     712             :             } else {
     713         232 :                 sl->pwt.implicit_weight[ref0][ref1][field] = w;
     714             :             }
     715             :         }
     716             :     }
     717             : }
     718             : 
     719             : /**
     720             :  * initialize scan tables
     721             :  */
     722         502 : static void init_scan_tables(H264Context *h)
     723             : {
     724             :     int i;
     725        8534 :     for (i = 0; i < 16; i++) {
     726             : #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
     727        8032 :         h->zigzag_scan[i] = TRANSPOSE(ff_zigzag_scan[i]);
     728        8032 :         h->field_scan[i]  = TRANSPOSE(field_scan[i]);
     729             : #undef TRANSPOSE
     730             :     }
     731       32630 :     for (i = 0; i < 64; i++) {
     732             : #define TRANSPOSE(x) ((x) >> 3) | (((x) & 7) << 3)
     733       32128 :         h->zigzag_scan8x8[i]       = TRANSPOSE(ff_zigzag_direct[i]);
     734       32128 :         h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
     735       32128 :         h->field_scan8x8[i]        = TRANSPOSE(field_scan8x8[i]);
     736       32128 :         h->field_scan8x8_cavlc[i]  = TRANSPOSE(field_scan8x8_cavlc[i]);
     737             : #undef TRANSPOSE
     738             :     }
     739         502 :     if (h->ps.sps->transform_bypass) { // FIXME same ugly
     740          12 :         memcpy(h->zigzag_scan_q0          , ff_zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
     741          12 :         memcpy(h->zigzag_scan8x8_q0       , ff_zigzag_direct        , sizeof(h->zigzag_scan8x8_q0      ));
     742          12 :         memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc    , sizeof(h->zigzag_scan8x8_cavlc_q0));
     743          12 :         memcpy(h->field_scan_q0           , field_scan              , sizeof(h->field_scan_q0          ));
     744          12 :         memcpy(h->field_scan8x8_q0        , field_scan8x8           , sizeof(h->field_scan8x8_q0       ));
     745          12 :         memcpy(h->field_scan8x8_cavlc_q0  , field_scan8x8_cavlc     , sizeof(h->field_scan8x8_cavlc_q0 ));
     746             :     } else {
     747         490 :         memcpy(h->zigzag_scan_q0          , h->zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
     748         490 :         memcpy(h->zigzag_scan8x8_q0       , h->zigzag_scan8x8       , sizeof(h->zigzag_scan8x8_q0      ));
     749         490 :         memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
     750         490 :         memcpy(h->field_scan_q0           , h->field_scan           , sizeof(h->field_scan_q0          ));
     751         490 :         memcpy(h->field_scan8x8_q0        , h->field_scan8x8        , sizeof(h->field_scan8x8_q0       ));
     752         490 :         memcpy(h->field_scan8x8_cavlc_q0  , h->field_scan8x8_cavlc  , sizeof(h->field_scan8x8_cavlc_q0 ));
     753             :     }
     754         502 : }
     755             : 
     756       25333 : static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
     757             : {
     758             : #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
     759             :                      (CONFIG_H264_D3D11VA_HWACCEL * 2) + \
     760             :                      CONFIG_H264_NVDEC_HWACCEL + \
     761             :                      CONFIG_H264_VAAPI_HWACCEL + \
     762             :                      CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \
     763             :                      CONFIG_H264_VDPAU_HWACCEL)
     764       25333 :     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
     765       25333 :     const enum AVPixelFormat *choices = pix_fmts;
     766             :     int i;
     767             : 
     768       25333 :     switch (h->ps.sps->bit_depth_luma) {
     769         155 :     case 9:
     770         155 :         if (CHROMA444(h)) {
     771           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     772           0 :                 *fmt++ = AV_PIX_FMT_GBRP9;
     773             :             } else
     774           0 :                 *fmt++ = AV_PIX_FMT_YUV444P9;
     775         155 :         } else if (CHROMA422(h))
     776          52 :             *fmt++ = AV_PIX_FMT_YUV422P9;
     777             :         else
     778         103 :             *fmt++ = AV_PIX_FMT_YUV420P9;
     779         155 :         break;
     780         355 :     case 10:
     781         355 :         if (CHROMA444(h)) {
     782          51 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     783           0 :                 *fmt++ = AV_PIX_FMT_GBRP10;
     784             :             } else
     785          51 :                 *fmt++ = AV_PIX_FMT_YUV444P10;
     786         304 :         } else if (CHROMA422(h))
     787         164 :             *fmt++ = AV_PIX_FMT_YUV422P10;
     788             :         else
     789         140 :             *fmt++ = AV_PIX_FMT_YUV420P10;
     790         355 :         break;
     791           0 :     case 12:
     792           0 :         if (CHROMA444(h)) {
     793           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     794           0 :                 *fmt++ = AV_PIX_FMT_GBRP12;
     795             :             } else
     796           0 :                 *fmt++ = AV_PIX_FMT_YUV444P12;
     797           0 :         } else if (CHROMA422(h))
     798           0 :             *fmt++ = AV_PIX_FMT_YUV422P12;
     799             :         else
     800           0 :             *fmt++ = AV_PIX_FMT_YUV420P12;
     801           0 :         break;
     802           0 :     case 14:
     803           0 :         if (CHROMA444(h)) {
     804           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     805           0 :                 *fmt++ = AV_PIX_FMT_GBRP14;
     806             :             } else
     807           0 :                 *fmt++ = AV_PIX_FMT_YUV444P14;
     808           0 :         } else if (CHROMA422(h))
     809           0 :             *fmt++ = AV_PIX_FMT_YUV422P14;
     810             :         else
     811           0 :             *fmt++ = AV_PIX_FMT_YUV420P14;
     812           0 :         break;
     813       24823 :     case 8:
     814             : #if CONFIG_H264_VDPAU_HWACCEL
     815             :         *fmt++ = AV_PIX_FMT_VDPAU;
     816             : #endif
     817             : #if CONFIG_H264_NVDEC_HWACCEL
     818       24823 :         *fmt++ = AV_PIX_FMT_CUDA;
     819             : #endif
     820       24823 :         if (CHROMA444(h)) {
     821         397 :             if (h->avctx->colorspace == AVCOL_SPC_RGB)
     822           0 :                 *fmt++ = AV_PIX_FMT_GBRP;
     823         397 :             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     824           0 :                 *fmt++ = AV_PIX_FMT_YUVJ444P;
     825             :             else
     826         397 :                 *fmt++ = AV_PIX_FMT_YUV444P;
     827       24426 :         } else if (CHROMA422(h)) {
     828          22 :             if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     829           0 :                 *fmt++ = AV_PIX_FMT_YUVJ422P;
     830             :             else
     831          22 :                 *fmt++ = AV_PIX_FMT_YUV422P;
     832             :         } else {
     833             : #if CONFIG_H264_DXVA2_HWACCEL
     834             :             *fmt++ = AV_PIX_FMT_DXVA2_VLD;
     835             : #endif
     836             : #if CONFIG_H264_D3D11VA_HWACCEL
     837             :             *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
     838             :             *fmt++ = AV_PIX_FMT_D3D11;
     839             : #endif
     840             : #if CONFIG_H264_VAAPI_HWACCEL
     841             :             *fmt++ = AV_PIX_FMT_VAAPI;
     842             : #endif
     843             : #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
     844             :             *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
     845             : #endif
     846       24404 :             if (h->avctx->codec->pix_fmts)
     847           0 :                 choices = h->avctx->codec->pix_fmts;
     848       24404 :             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     849           3 :                 *fmt++ = AV_PIX_FMT_YUVJ420P;
     850             :             else
     851       24401 :                 *fmt++ = AV_PIX_FMT_YUV420P;
     852             :         }
     853       24823 :         break;
     854           0 :     default:
     855           0 :         av_log(h->avctx, AV_LOG_ERROR,
     856           0 :                "Unsupported bit depth %d\n", h->ps.sps->bit_depth_luma);
     857           0 :         return AVERROR_INVALIDDATA;
     858             :     }
     859             : 
     860       25333 :     *fmt = AV_PIX_FMT_NONE;
     861             : 
     862       50661 :     for (i=0; choices[i] != AV_PIX_FMT_NONE; i++)
     863       50156 :         if (choices[i] == h->avctx->pix_fmt && !force_callback)
     864       24828 :             return choices[i];
     865         505 :     return ff_thread_get_format(h->avctx, choices);
     866             : }
     867             : 
     868             : /* export coded and cropped frame dimensions to AVCodecContext */
     869       25098 : static int init_dimensions(H264Context *h)
     870             : {
     871       25098 :     const SPS *sps = (const SPS*)h->ps.sps;
     872       25098 :     int cr = sps->crop_right;
     873       25098 :     int cl = sps->crop_left;
     874       25098 :     int ct = sps->crop_top;
     875       25098 :     int cb = sps->crop_bottom;
     876       25098 :     int width  = h->width  - (cr + cl);
     877       25098 :     int height = h->height - (ct + cb);
     878       25098 :     av_assert0(sps->crop_right + sps->crop_left < (unsigned)h->width);
     879       25098 :     av_assert0(sps->crop_top + sps->crop_bottom < (unsigned)h->height);
     880             : 
     881             :     /* handle container cropping */
     882       48016 :     if (h->width_from_caller > 0 && h->height_from_caller > 0     &&
     883       68752 :         !sps->crop_top && !sps->crop_left                         &&
     884       45829 :         FFALIGN(h->width_from_caller,  16) == FFALIGN(width,  16) &&
     885       45824 :         FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16) &&
     886       45824 :         h->width_from_caller  <= width &&
     887       22912 :         h->height_from_caller <= height) {
     888       22911 :         width  = h->width_from_caller;
     889       22911 :         height = h->height_from_caller;
     890       22911 :         cl = 0;
     891       22911 :         ct = 0;
     892       22911 :         cr = h->width - width;
     893       22911 :         cb = h->height - height;
     894             :     } else {
     895        2187 :         h->width_from_caller  = 0;
     896        2187 :         h->height_from_caller = 0;
     897             :     }
     898             : 
     899       25098 :     h->avctx->coded_width  = h->width;
     900       25098 :     h->avctx->coded_height = h->height;
     901       25098 :     h->avctx->width        = width;
     902       25098 :     h->avctx->height       = height;
     903       25098 :     h->crop_right          = cr;
     904       25098 :     h->crop_left           = cl;
     905       25098 :     h->crop_top            = ct;
     906       25098 :     h->crop_bottom         = cb;
     907             : 
     908       25098 :     return 0;
     909             : }
     910             : 
     911         502 : static int h264_slice_header_init(H264Context *h)
     912             : {
     913         502 :     const SPS *sps = h->ps.sps;
     914             :     int i, ret;
     915             : 
     916         502 :     ff_set_sar(h->avctx, sps->sar);
     917         502 :     av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
     918             :                                      &h->chroma_x_shift, &h->chroma_y_shift);
     919             : 
     920         502 :     if (sps->timing_info_present_flag) {
     921         100 :         int64_t den = sps->time_scale;
     922         100 :         if (h->x264_build < 44U)
     923           0 :             den *= 2;
     924         100 :         av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
     925         100 :                   sps->num_units_in_tick * h->avctx->ticks_per_frame, den, 1 << 30);
     926             :     }
     927             : 
     928         502 :     ff_h264_free_tables(h);
     929             : 
     930         502 :     h->first_field           = 0;
     931         502 :     h->prev_interlaced_frame = 1;
     932             : 
     933         502 :     init_scan_tables(h);
     934         502 :     ret = ff_h264_alloc_tables(h);
     935         502 :     if (ret < 0) {
     936           0 :         av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
     937           0 :         goto fail;
     938             :     }
     939             : 
     940        1004 :     if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
     941        1004 :         sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13
     942             :     ) {
     943           0 :         av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
     944             :                sps->bit_depth_luma);
     945           0 :         ret = AVERROR_INVALIDDATA;
     946           0 :         goto fail;
     947             :     }
     948             : 
     949         502 :     h->cur_bit_depth_luma         =
     950         502 :     h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
     951         502 :     h->cur_chroma_format_idc      = sps->chroma_format_idc;
     952         502 :     h->pixel_shift                = sps->bit_depth_luma > 8;
     953         502 :     h->chroma_format_idc          = sps->chroma_format_idc;
     954         502 :     h->bit_depth_luma             = sps->bit_depth_luma;
     955             : 
     956         502 :     ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
     957             :                     sps->chroma_format_idc);
     958         502 :     ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
     959         502 :     ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
     960         502 :     ff_h264_pred_init(&h->hpc, h->avctx->codec_id, sps->bit_depth_luma,
     961             :                       sps->chroma_format_idc);
     962         502 :     ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
     963             : 
     964         502 :     if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
     965         502 :         ret = ff_h264_slice_context_init(h, &h->slice_ctx[0]);
     966         502 :         if (ret < 0) {
     967           0 :             av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
     968           0 :             goto fail;
     969             :         }
     970             :     } else {
     971           0 :         for (i = 0; i < h->nb_slice_ctx; i++) {
     972           0 :             H264SliceContext *sl = &h->slice_ctx[i];
     973             : 
     974           0 :             sl->h264               = h;
     975           0 :             sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
     976           0 :             sl->mvd_table[0]       = h->mvd_table[0]       + i * 8 * 2 * h->mb_stride;
     977           0 :             sl->mvd_table[1]       = h->mvd_table[1]       + i * 8 * 2 * h->mb_stride;
     978             : 
     979           0 :             if ((ret = ff_h264_slice_context_init(h, sl)) < 0) {
     980           0 :                 av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
     981           0 :                 goto fail;
     982             :             }
     983             :         }
     984             :     }
     985             : 
     986         502 :     h->context_initialized = 1;
     987             : 
     988         502 :     return 0;
     989           0 : fail:
     990           0 :     ff_h264_free_tables(h);
     991           0 :     h->context_initialized = 0;
     992           0 :     return ret;
     993             : }
     994             : 
     995       49662 : static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
     996             : {
     997       49662 :     switch (a) {
     998           2 :     case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
     999           0 :     case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
    1000           0 :     case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
    1001       49660 :     default:
    1002       49660 :         return a;
    1003             :     }
    1004             : }
    1005             : 
    1006       25098 : static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
    1007             : {
    1008             :     const SPS *sps;
    1009       25098 :     int needs_reinit = 0, must_reinit, ret;
    1010             : 
    1011       25098 :     if (first_slice) {
    1012       24905 :         av_buffer_unref(&h->ps.pps_ref);
    1013       24905 :         h->ps.pps = NULL;
    1014       24905 :         h->ps.pps_ref = av_buffer_ref(h->ps.pps_list[sl->pps_id]);
    1015       24905 :         if (!h->ps.pps_ref)
    1016           0 :             return AVERROR(ENOMEM);
    1017       24905 :         h->ps.pps = (const PPS*)h->ps.pps_ref->data;
    1018             :     }
    1019             : 
    1020       25098 :     if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
    1021         507 :         av_buffer_unref(&h->ps.sps_ref);
    1022         507 :         h->ps.sps = NULL;
    1023         507 :         h->ps.sps_ref = av_buffer_ref(h->ps.sps_list[h->ps.pps->sps_id]);
    1024         507 :         if (!h->ps.sps_ref)
    1025           0 :             return AVERROR(ENOMEM);
    1026         507 :         h->ps.sps = (const SPS*)h->ps.sps_ref->data;
    1027             : 
    1028         514 :         if (h->mb_width  != h->ps.sps->mb_width ||
    1029          14 :             h->mb_height != h->ps.sps->mb_height ||
    1030          13 :             h->cur_bit_depth_luma    != h->ps.sps->bit_depth_luma ||
    1031           6 :             h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
    1032             :         )
    1033         502 :             needs_reinit = 1;
    1034             : 
    1035         516 :         if (h->bit_depth_luma    != h->ps.sps->bit_depth_luma ||
    1036           9 :             h->chroma_format_idc != h->ps.sps->chroma_format_idc)
    1037         499 :             needs_reinit         = 1;
    1038             :     }
    1039       25098 :     sps = h->ps.sps;
    1040             : 
    1041       49706 :     must_reinit = (h->context_initialized &&
    1042       24602 :                     (   16*sps->mb_width != h->avctx->coded_width
    1043       24598 :                      || 16*sps->mb_height != h->avctx->coded_height
    1044       24598 :                      || h->cur_bit_depth_luma    != sps->bit_depth_luma
    1045       24597 :                      || h->cur_chroma_format_idc != sps->chroma_format_idc
    1046       24596 :                      || h->mb_width  != sps->mb_width
    1047       24596 :                      || h->mb_height != sps->mb_height
    1048             :                     ));
    1049       25098 :     if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
    1050       24831 :         || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
    1051         270 :         must_reinit = 1;
    1052             : 
    1053       25098 :     if (first_slice && av_cmp_q(sps->sar, h->avctx->sample_aspect_ratio))
    1054          34 :         must_reinit = 1;
    1055             : 
    1056       25098 :     if (!h->setup_finished) {
    1057       25098 :         h->avctx->profile = ff_h264_get_profile(sps);
    1058       25098 :         h->avctx->level   = sps->level_idc;
    1059       25098 :         h->avctx->refs    = sps->ref_frame_count;
    1060             : 
    1061       25098 :         h->mb_width  = sps->mb_width;
    1062       25098 :         h->mb_height = sps->mb_height;
    1063       25098 :         h->mb_num    = h->mb_width * h->mb_height;
    1064       25098 :         h->mb_stride = h->mb_width + 1;
    1065             : 
    1066       25098 :         h->b_stride = h->mb_width * 4;
    1067             : 
    1068       25098 :         h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p
    1069             : 
    1070       25098 :         h->width  = 16 * h->mb_width;
    1071       25098 :         h->height = 16 * h->mb_height;
    1072             : 
    1073       25098 :         ret = init_dimensions(h);
    1074       25098 :         if (ret < 0)
    1075           0 :             return ret;
    1076             : 
    1077       25098 :         if (sps->video_signal_type_present_flag) {
    1078        1342 :             h->avctx->color_range = sps->full_range > 0 ? AVCOL_RANGE_JPEG
    1079         671 :                                                         : AVCOL_RANGE_MPEG;
    1080         671 :             if (sps->colour_description_present_flag) {
    1081         573 :                 if (h->avctx->colorspace != sps->colorspace)
    1082          14 :                     needs_reinit = 1;
    1083         573 :                 h->avctx->color_primaries = sps->color_primaries;
    1084         573 :                 h->avctx->color_trc       = sps->color_trc;
    1085         573 :                 h->avctx->colorspace      = sps->colorspace;
    1086             :             }
    1087             :         }
    1088             :     }
    1089             : 
    1090       25098 :     if (!h->context_initialized || must_reinit || needs_reinit) {
    1091         502 :         int flush_changes = h->context_initialized;
    1092         502 :         h->context_initialized = 0;
    1093         502 :         if (sl != h->slice_ctx) {
    1094           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1095             :                    "changing width %d -> %d / height %d -> %d on "
    1096             :                    "slice %d\n",
    1097           0 :                    h->width, h->avctx->coded_width,
    1098           0 :                    h->height, h->avctx->coded_height,
    1099           0 :                    h->current_slice + 1);
    1100           0 :             return AVERROR_INVALIDDATA;
    1101             :         }
    1102             : 
    1103             :         av_assert1(first_slice);
    1104             : 
    1105         502 :         if (flush_changes)
    1106           6 :             ff_h264_flush_change(h);
    1107             : 
    1108         502 :         if ((ret = get_pixel_format(h, 1)) < 0)
    1109           0 :             return ret;
    1110         502 :         h->avctx->pix_fmt = ret;
    1111             : 
    1112         502 :         av_log(h->avctx, AV_LOG_VERBOSE, "Reinit context to %dx%d, "
    1113         502 :                "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
    1114             : 
    1115         502 :         if ((ret = h264_slice_header_init(h)) < 0) {
    1116           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1117             :                    "h264_slice_header_init() failed\n");
    1118           0 :             return ret;
    1119             :         }
    1120             :     }
    1121             : 
    1122       25098 :     return 0;
    1123             : }
    1124             : 
    1125       21861 : static int h264_export_frame_props(H264Context *h)
    1126             : {
    1127       21861 :     const SPS *sps = h->ps.sps;
    1128       21861 :     H264Picture *cur = h->cur_pic_ptr;
    1129             : 
    1130       21861 :     cur->f->interlaced_frame = 0;
    1131       21861 :     cur->f->repeat_pict      = 0;
    1132             : 
    1133             :     /* Signal interlacing information externally. */
    1134             :     /* Prioritize picture timing SEI information over used
    1135             :      * decoding process if it exists. */
    1136             : 
    1137       22235 :     if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
    1138         374 :         H264SEIPictureTiming *pt = &h->sei.picture_timing;
    1139         374 :         switch (pt->pic_struct) {
    1140          21 :         case H264_SEI_PIC_STRUCT_FRAME:
    1141          21 :             break;
    1142         248 :         case H264_SEI_PIC_STRUCT_TOP_FIELD:
    1143             :         case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
    1144         248 :             cur->f->interlaced_frame = 1;
    1145         248 :             break;
    1146         102 :         case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
    1147             :         case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
    1148         102 :             if (FIELD_OR_MBAFF_PICTURE(h))
    1149          98 :                 cur->f->interlaced_frame = 1;
    1150             :             else
    1151             :                 // try to flag soft telecine progressive
    1152           4 :                 cur->f->interlaced_frame = h->prev_interlaced_frame;
    1153         102 :             break;
    1154           3 :         case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
    1155             :         case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
    1156             :             /* Signal the possibility of telecined film externally
    1157             :              * (pic_struct 5,6). From these hints, let the applications
    1158             :              * decide if they apply deinterlacing. */
    1159           3 :             cur->f->repeat_pict = 1;
    1160           3 :             break;
    1161           0 :         case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
    1162           0 :             cur->f->repeat_pict = 2;
    1163           0 :             break;
    1164           0 :         case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
    1165           0 :             cur->f->repeat_pict = 4;
    1166           0 :             break;
    1167             :         }
    1168             : 
    1169         560 :         if ((pt->ct_type & 3) &&
    1170         186 :             pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
    1171         186 :             cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
    1172             :     } else {
    1173             :         /* Derive interlacing flag from used decoding process. */
    1174       21487 :         cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
    1175             :     }
    1176       21861 :     h->prev_interlaced_frame = cur->f->interlaced_frame;
    1177             : 
    1178       21861 :     if (cur->field_poc[0] != cur->field_poc[1]) {
    1179             :         /* Derive top_field_first from field pocs. */
    1180        2569 :         cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
    1181             :     } else {
    1182       19292 :         if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
    1183             :             /* Use picture timing SEI information. Even if it is a
    1184             :              * information of a past frame, better than nothing. */
    1185          83 :             if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
    1186          27 :                 h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
    1187           3 :                 cur->f->top_field_first = 1;
    1188             :             else
    1189          25 :                 cur->f->top_field_first = 0;
    1190       19264 :         } else if (cur->f->interlaced_frame) {
    1191             :             /* Default to top field first when pic_struct_present_flag
    1192             :              * is not set but interlaced frame detected */
    1193        2554 :             cur->f->top_field_first = 1;
    1194             :         } else {
    1195             :             /* Most likely progressive */
    1196       16710 :             cur->f->top_field_first = 0;
    1197             :         }
    1198             :     }
    1199             : 
    1200       21861 :     if (h->sei.frame_packing.present &&
    1201           0 :         h->sei.frame_packing.arrangement_type <= 6 &&
    1202           0 :         h->sei.frame_packing.content_interpretation_type > 0 &&
    1203           0 :         h->sei.frame_packing.content_interpretation_type < 3) {
    1204           0 :         H264SEIFramePacking *fp = &h->sei.frame_packing;
    1205           0 :         AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
    1206           0 :         if (stereo) {
    1207           0 :         switch (fp->arrangement_type) {
    1208           0 :         case H264_SEI_FPA_TYPE_CHECKERBOARD:
    1209           0 :             stereo->type = AV_STEREO3D_CHECKERBOARD;
    1210           0 :             break;
    1211           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN:
    1212           0 :             stereo->type = AV_STEREO3D_COLUMNS;
    1213           0 :             break;
    1214           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_ROW:
    1215           0 :             stereo->type = AV_STEREO3D_LINES;
    1216           0 :             break;
    1217           0 :         case H264_SEI_FPA_TYPE_SIDE_BY_SIDE:
    1218           0 :             if (fp->quincunx_sampling_flag)
    1219           0 :                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
    1220             :             else
    1221           0 :                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
    1222           0 :             break;
    1223           0 :         case H264_SEI_FPA_TYPE_TOP_BOTTOM:
    1224           0 :             stereo->type = AV_STEREO3D_TOPBOTTOM;
    1225           0 :             break;
    1226           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
    1227           0 :             stereo->type = AV_STEREO3D_FRAMESEQUENCE;
    1228           0 :             break;
    1229           0 :         case H264_SEI_FPA_TYPE_2D:
    1230           0 :             stereo->type = AV_STEREO3D_2D;
    1231           0 :             break;
    1232             :         }
    1233             : 
    1234           0 :         if (fp->content_interpretation_type == 2)
    1235           0 :             stereo->flags = AV_STEREO3D_FLAG_INVERT;
    1236             : 
    1237           0 :         if (fp->arrangement_type == H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL) {
    1238           0 :             if (fp->current_frame_is_frame0_flag)
    1239           0 :                 stereo->view = AV_STEREO3D_VIEW_LEFT;
    1240             :             else
    1241           0 :                 stereo->view = AV_STEREO3D_VIEW_RIGHT;
    1242             :         }
    1243             :         }
    1244             :     }
    1245             : 
    1246       21861 :     if (h->sei.display_orientation.present &&
    1247           0 :         (h->sei.display_orientation.anticlockwise_rotation ||
    1248           0 :          h->sei.display_orientation.hflip ||
    1249           0 :          h->sei.display_orientation.vflip)) {
    1250           0 :         H264SEIDisplayOrientation *o = &h->sei.display_orientation;
    1251           0 :         double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
    1252           0 :         AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
    1253             :                                                            AV_FRAME_DATA_DISPLAYMATRIX,
    1254             :                                                            sizeof(int32_t) * 9);
    1255           0 :         if (rotation) {
    1256           0 :             av_display_rotation_set((int32_t *)rotation->data, angle);
    1257           0 :             av_display_matrix_flip((int32_t *)rotation->data,
    1258             :                                    o->hflip, o->vflip);
    1259             :         }
    1260             :     }
    1261             : 
    1262       21861 :     if (h->sei.afd.present) {
    1263         136 :         AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
    1264             :                                                      sizeof(uint8_t));
    1265             : 
    1266         136 :         if (sd) {
    1267         136 :             *sd->data = h->sei.afd.active_format_description;
    1268         136 :             h->sei.afd.present = 0;
    1269             :         }
    1270             :     }
    1271             : 
    1272       21861 :     if (h->sei.a53_caption.a53_caption) {
    1273           0 :         H264SEIA53Caption *a53 = &h->sei.a53_caption;
    1274           0 :         AVFrameSideData *sd = av_frame_new_side_data(cur->f,
    1275             :                                                      AV_FRAME_DATA_A53_CC,
    1276             :                                                      a53->a53_caption_size);
    1277           0 :         if (sd)
    1278           0 :             memcpy(sd->data, a53->a53_caption, a53->a53_caption_size);
    1279           0 :         av_freep(&a53->a53_caption);
    1280           0 :         a53->a53_caption_size = 0;
    1281           0 :         h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
    1282             :     }
    1283             : 
    1284       21861 :     if (h->sei.alternative_transfer.present &&
    1285           0 :         av_color_transfer_name(h->sei.alternative_transfer.preferred_transfer_characteristics) &&
    1286           0 :         h->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
    1287           0 :         h->avctx->color_trc = cur->f->color_trc = h->sei.alternative_transfer.preferred_transfer_characteristics;
    1288             :     }
    1289             : 
    1290       21861 :     return 0;
    1291             : }
    1292             : 
    1293       21861 : static int h264_select_output_frame(H264Context *h)
    1294             : {
    1295       21861 :     const SPS *sps = h->ps.sps;
    1296       21861 :     H264Picture *out = h->cur_pic_ptr;
    1297       21861 :     H264Picture *cur = h->cur_pic_ptr;
    1298             :     int i, pics, out_of_order, out_idx;
    1299             : 
    1300       21861 :     cur->mmco_reset = h->mmco_reset;
    1301       21861 :     h->mmco_reset = 0;
    1302             : 
    1303       41052 :     if (sps->bitstream_restriction_flag ||
    1304       19191 :         h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
    1305        2670 :         h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
    1306             :     }
    1307             : 
    1308      357623 :     for (i = 0; 1; i++) {
    1309      693385 :         if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
    1310       21861 :             if(i)
    1311       21861 :                 h->last_pocs[i-1] = cur->poc;
    1312       21861 :             break;
    1313      335762 :         } else if(i) {
    1314      313901 :             h->last_pocs[i-1]= h->last_pocs[i];
    1315             :         }
    1316             :     }
    1317       21861 :     out_of_order = MAX_DELAYED_PIC_COUNT - i;
    1318       21861 :     if(   cur->f->pict_type == AV_PICTURE_TYPE_B
    1319       14642 :        || (h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > INT_MIN && h->last_pocs[MAX_DELAYED_PIC_COUNT-1] - h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > 2))
    1320       11706 :         out_of_order = FFMAX(out_of_order, 1);
    1321       21861 :     if (out_of_order == MAX_DELAYED_PIC_COUNT) {
    1322           0 :         av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
    1323           0 :         for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
    1324           0 :             h->last_pocs[i] = INT_MIN;
    1325           0 :         h->last_pocs[0] = cur->poc;
    1326           0 :         cur->mmco_reset = 1;
    1327       21861 :     } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
    1328         135 :         int loglevel = h->avctx->frame_number > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
    1329         135 :         av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
    1330         135 :         h->avctx->has_b_frames = out_of_order;
    1331             :     }
    1332             : 
    1333       21861 :     pics = 0;
    1334       68247 :     while (h->delayed_pic[pics])
    1335       24525 :         pics++;
    1336             : 
    1337       21861 :     av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
    1338             : 
    1339       21861 :     h->delayed_pic[pics++] = cur;
    1340       21861 :     if (cur->reference == 0)
    1341       20450 :         cur->reference = DELAYED_PIC_REF;
    1342             : 
    1343       21861 :     out     = h->delayed_pic[0];
    1344       21861 :     out_idx = 0;
    1345       91578 :     for (i = 1; h->delayed_pic[i] &&
    1346       47943 :                 !h->delayed_pic[i]->f->key_frame &&
    1347       23917 :                 !h->delayed_pic[i]->mmco_reset;
    1348       23830 :          i++)
    1349       23830 :         if (h->delayed_pic[i]->poc < out->poc) {
    1350        9375 :             out     = h->delayed_pic[i];
    1351        9375 :             out_idx = i;
    1352             :         }
    1353       30938 :     if (h->avctx->has_b_frames == 0 &&
    1354       17436 :         (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset))
    1355         724 :         h->next_outputed_poc = INT_MIN;
    1356       21861 :     out_of_order = out->poc < h->next_outputed_poc;
    1357             : 
    1358       21861 :     if (out_of_order || pics > h->avctx->has_b_frames) {
    1359       21466 :         out->reference &= ~DELAYED_PIC_REF;
    1360       53410 :         for (i = out_idx; h->delayed_pic[i]; i++)
    1361       31944 :             h->delayed_pic[i] = h->delayed_pic[i + 1];
    1362             :     }
    1363       21861 :     if (!out_of_order && pics > h->avctx->has_b_frames) {
    1364       21215 :         h->next_output_pic = out;
    1365       21215 :         if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset)) {
    1366          83 :             h->next_outputed_poc = INT_MIN;
    1367             :         } else
    1368       21132 :             h->next_outputed_poc = out->poc;
    1369             : 
    1370       21215 :         if (out->recovered) {
    1371             :             // We have reached an recovery point and all frames after it in
    1372             :             // display order are "recovered".
    1373       21153 :             h->frame_recovered |= FRAME_RECOVERED_SEI;
    1374             :         }
    1375       21215 :         out->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
    1376             : 
    1377       42430 :         if (!out->recovered) {
    1378         114 :             if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
    1379          57 :                 !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
    1380          57 :                 h->next_output_pic = NULL;
    1381             :             } else {
    1382           0 :                 out->f->flags |= AV_FRAME_FLAG_CORRUPT;
    1383             :             }
    1384             :         }
    1385             :     } else {
    1386         646 :         av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
    1387             :     }
    1388             : 
    1389       21861 :     return 0;
    1390             : }
    1391             : 
    1392             : /* This function is called right after decoding the slice header for a first
    1393             :  * slice in a field (or a frame). It decides whether we are decoding a new frame
    1394             :  * or a second field in a pair and does the necessary setup.
    1395             :  */
    1396       25098 : static int h264_field_start(H264Context *h, const H264SliceContext *sl,
    1397             :                             const H2645NAL *nal, int first_slice)
    1398             : {
    1399             :     int i;
    1400             :     const SPS *sps;
    1401             : 
    1402             :     int last_pic_structure, last_pic_droppable, ret;
    1403             : 
    1404       25098 :     ret = h264_init_ps(h, sl, first_slice);
    1405       25098 :     if (ret < 0)
    1406           0 :         return ret;
    1407             : 
    1408       25098 :     sps = h->ps.sps;
    1409             : 
    1410       25098 :     last_pic_droppable   = h->droppable;
    1411       25098 :     last_pic_structure   = h->picture_structure;
    1412       25098 :     h->droppable         = (nal->ref_idc == 0);
    1413       25098 :     h->picture_structure = sl->picture_structure;
    1414             : 
    1415       25098 :     h->poc.frame_num        = sl->frame_num;
    1416       25098 :     h->poc.poc_lsb          = sl->poc_lsb;
    1417       25098 :     h->poc.delta_poc_bottom = sl->delta_poc_bottom;
    1418       25098 :     h->poc.delta_poc[0]     = sl->delta_poc[0];
    1419       25098 :     h->poc.delta_poc[1]     = sl->delta_poc[1];
    1420             : 
    1421             :     /* Shorten frame num gaps so we don't have to allocate reference
    1422             :      * frames just to throw them away */
    1423       25098 :     if (h->poc.frame_num != h->poc.prev_frame_num) {
    1424       14004 :         int unwrap_prev_frame_num = h->poc.prev_frame_num;
    1425       14004 :         int max_frame_num         = 1 << sps->log2_max_frame_num;
    1426             : 
    1427       14004 :         if (unwrap_prev_frame_num > h->poc.frame_num)
    1428         113 :             unwrap_prev_frame_num -= max_frame_num;
    1429             : 
    1430       14004 :         if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
    1431          53 :             unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
    1432          53 :             if (unwrap_prev_frame_num < 0)
    1433           2 :                 unwrap_prev_frame_num += max_frame_num;
    1434             : 
    1435          53 :             h->poc.prev_frame_num = unwrap_prev_frame_num;
    1436             :         }
    1437             :     }
    1438             : 
    1439             :     /* See if we have a decoded first field looking for a pair...
    1440             :      * Here, we're using that to see if we should mark previously
    1441             :      * decode frames as "finished".
    1442             :      * We have to do that before the "dummy" in-between frame allocation,
    1443             :      * since that can modify h->cur_pic_ptr. */
    1444       25098 :     if (h->first_field) {
    1445        3234 :         int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
    1446        3234 :         av_assert0(h->cur_pic_ptr);
    1447        3234 :         av_assert0(h->cur_pic_ptr->f->buf[0]);
    1448             :         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
    1449             : 
    1450             :         /* Mark old field/frame as completed */
    1451        3234 :         if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
    1452        3234 :             ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
    1453             :         }
    1454             : 
    1455             :         /* figure out if we have a complementary field pair */
    1456        3234 :         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
    1457             :             /* Previous field is unmatched. Don't display it, but let it
    1458             :              * remain for reference if marked as such. */
    1459           0 :             if (last_pic_structure != PICT_FRAME) {
    1460           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1461             :                                           last_pic_structure == PICT_TOP_FIELD);
    1462             :             }
    1463             :         } else {
    1464        3234 :             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
    1465             :                 /* This and previous field were reference, but had
    1466             :                  * different frame_nums. Consider this field first in
    1467             :                  * pair. Throw away previous field except for reference
    1468             :                  * purposes. */
    1469           0 :                 if (last_pic_structure != PICT_FRAME) {
    1470           0 :                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1471             :                                               last_pic_structure == PICT_TOP_FIELD);
    1472             :                 }
    1473             :             } else {
    1474             :                 /* Second field in complementary pair */
    1475        6460 :                 if (!((last_pic_structure   == PICT_TOP_FIELD &&
    1476        3226 :                        h->picture_structure == PICT_BOTTOM_FIELD) ||
    1477           8 :                       (last_pic_structure   == PICT_BOTTOM_FIELD &&
    1478           8 :                        h->picture_structure == PICT_TOP_FIELD))) {
    1479           0 :                     av_log(h->avctx, AV_LOG_ERROR,
    1480             :                            "Invalid field mode combination %d/%d\n",
    1481             :                            last_pic_structure, h->picture_structure);
    1482           0 :                     h->picture_structure = last_pic_structure;
    1483           0 :                     h->droppable         = last_pic_droppable;
    1484           0 :                     return AVERROR_INVALIDDATA;
    1485        3234 :                 } else if (last_pic_droppable != h->droppable) {
    1486           0 :                     avpriv_request_sample(h->avctx,
    1487             :                                           "Found reference and non-reference fields in the same frame, which");
    1488           0 :                     h->picture_structure = last_pic_structure;
    1489           0 :                     h->droppable         = last_pic_droppable;
    1490           0 :                     return AVERROR_PATCHWELCOME;
    1491             :                 }
    1492             :             }
    1493             :         }
    1494             :     }
    1495             : 
    1496       65452 :     while (h->poc.frame_num != h->poc.prev_frame_num && !h->first_field &&
    1497       14630 :            h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
    1498         626 :         H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
    1499         626 :         av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
    1500             :                h->poc.frame_num, h->poc.prev_frame_num);
    1501         626 :         if (!sps->gaps_in_frame_num_allowed_flag)
    1502         833 :             for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
    1503         784 :                 h->last_pocs[i] = INT_MIN;
    1504         626 :         ret = h264_frame_start(h);
    1505         626 :         if (ret < 0) {
    1506           0 :             h->first_field = 0;
    1507           0 :             return ret;
    1508             :         }
    1509             : 
    1510         626 :         h->poc.prev_frame_num++;
    1511         626 :         h->poc.prev_frame_num        %= 1 << sps->log2_max_frame_num;
    1512         626 :         h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
    1513         626 :         h->cur_pic_ptr->invalid_gap = !sps->gaps_in_frame_num_allowed_flag;
    1514         626 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
    1515         626 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
    1516             : 
    1517         626 :         h->explicit_ref_marking = 0;
    1518         626 :         ret = ff_h264_execute_ref_pic_marking(h);
    1519         626 :         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    1520           0 :             return ret;
    1521             :         /* Error concealment: If a ref is missing, copy the previous ref
    1522             :          * in its place.
    1523             :          * FIXME: Avoiding a memcpy would be nice, but ref handling makes
    1524             :          * many assumptions about there being no actual duplicates.
    1525             :          * FIXME: This does not copy padding for out-of-frame motion
    1526             :          * vectors.  Given we are concealing a lost frame, this probably
    1527             :          * is not noticeable by comparison, but it should be fixed. */
    1528         626 :         if (h->short_ref_count) {
    1529        1238 :             if (prev &&
    1530        1224 :                 h->short_ref[0]->f->width == prev->f->width &&
    1531        1224 :                 h->short_ref[0]->f->height == prev->f->height &&
    1532         612 :                 h->short_ref[0]->f->format == prev->f->format) {
    1533         612 :                 ff_thread_await_progress(&prev->tf, INT_MAX, 0);
    1534         612 :                 if (prev->field_picture)
    1535          14 :                     ff_thread_await_progress(&prev->tf, INT_MAX, 1);
    1536        1836 :                 av_image_copy(h->short_ref[0]->f->data,
    1537         612 :                               h->short_ref[0]->f->linesize,
    1538         612 :                               (const uint8_t **)prev->f->data,
    1539         612 :                               prev->f->linesize,
    1540         612 :                               prev->f->format,
    1541         612 :                               prev->f->width,
    1542         612 :                               prev->f->height);
    1543         612 :                 h->short_ref[0]->poc = prev->poc + 2;
    1544             :             }
    1545         626 :             h->short_ref[0]->frame_num = h->poc.prev_frame_num;
    1546             :         }
    1547             :     }
    1548             : 
    1549             :     /* See if we have a decoded first field looking for a pair...
    1550             :      * We're using that to see whether to continue decoding in that
    1551             :      * frame, or to allocate a new one. */
    1552       25098 :     if (h->first_field) {
    1553        3234 :         av_assert0(h->cur_pic_ptr);
    1554        3234 :         av_assert0(h->cur_pic_ptr->f->buf[0]);
    1555             :         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
    1556             : 
    1557             :         /* figure out if we have a complementary field pair */
    1558        3234 :         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
    1559             :             /* Previous field is unmatched. Don't display it, but let it
    1560             :              * remain for reference if marked as such. */
    1561           0 :             h->missing_fields ++;
    1562           0 :             h->cur_pic_ptr = NULL;
    1563           0 :             h->first_field = FIELD_PICTURE(h);
    1564             :         } else {
    1565        3234 :             h->missing_fields = 0;
    1566        3234 :             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
    1567           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1568           0 :                                           h->picture_structure==PICT_BOTTOM_FIELD);
    1569             :                 /* This and the previous field had different frame_nums.
    1570             :                  * Consider this field first in pair. Throw away previous
    1571             :                  * one except for reference purposes. */
    1572           0 :                 h->first_field = 1;
    1573           0 :                 h->cur_pic_ptr = NULL;
    1574             :             } else {
    1575             :                 /* Second field in complementary pair */
    1576        3234 :                 h->first_field = 0;
    1577             :             }
    1578             :         }
    1579             :     } else {
    1580             :         /* Frame or first field in a potentially complementary pair */
    1581       21864 :         h->first_field = FIELD_PICTURE(h);
    1582             :     }
    1583             : 
    1584       25098 :     if (!FIELD_PICTURE(h) || h->first_field) {
    1585       43728 :         if (h264_frame_start(h) < 0) {
    1586           0 :             h->first_field = 0;
    1587           0 :             return AVERROR_INVALIDDATA;
    1588             :         }
    1589             :     } else {
    1590        3234 :         int field = h->picture_structure == PICT_BOTTOM_FIELD;
    1591        3234 :         release_unused_pictures(h, 0);
    1592        3234 :         h->cur_pic_ptr->tf.owner[field] = h->avctx;
    1593             :     }
    1594             :     /* Some macroblocks can be accessed before they're available in case
    1595             :     * of lost slices, MBAFF or threading. */
    1596       25098 :     if (FIELD_PICTURE(h)) {
    1597      157337 :         for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
    1598      150866 :             memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
    1599             :     } else {
    1600       18627 :         memset(h->slice_table, -1,
    1601       18627 :             (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
    1602             :     }
    1603             : 
    1604       25098 :     ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
    1605             :                      h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
    1606             : 
    1607       25098 :     memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
    1608       25098 :     h->nb_mmco = sl->nb_mmco;
    1609       25098 :     h->explicit_ref_marking = sl->explicit_ref_marking;
    1610             : 
    1611       25098 :     h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
    1612             : 
    1613       25098 :     if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
    1614          39 :         const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
    1615             : 
    1616          39 :         if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
    1617          26 :             h->valid_recovery_point = 1;
    1618             : 
    1619          39 :         if (   h->recovery_frame < 0
    1620           1 :             || av_mod_uintp2(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
    1621          38 :             h->recovery_frame = av_mod_uintp2(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
    1622             : 
    1623          38 :             if (!h->valid_recovery_point)
    1624           6 :                 h->recovery_frame = h->poc.frame_num;
    1625             :         }
    1626             :     }
    1627             : 
    1628       25098 :     h->cur_pic_ptr->f->key_frame |= (nal->type == H264_NAL_IDR_SLICE);
    1629             : 
    1630       49265 :     if (nal->type == H264_NAL_IDR_SLICE ||
    1631       24196 :         (h->recovery_frame == h->poc.frame_num && nal->ref_idc)) {
    1632         958 :         h->recovery_frame         = -1;
    1633         958 :         h->cur_pic_ptr->recovered = 1;
    1634             :     }
    1635             :     // If we have an IDR, all frames after it in decoded order are
    1636             :     // "recovered".
    1637       25098 :     if (nal->type == H264_NAL_IDR_SLICE)
    1638         931 :         h->frame_recovered |= FRAME_RECOVERED_IDR;
    1639             : #if 1
    1640       25098 :     h->cur_pic_ptr->recovered |= h->frame_recovered;
    1641             : #else
    1642             :     h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
    1643             : #endif
    1644             : 
    1645             :     /* Set the frame properties/side data. Only done for the second field in
    1646             :      * field coded frames, since some SEI information is present for each field
    1647             :      * and is merged by the SEI parsing code. */
    1648       25098 :     if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
    1649       21861 :         ret = h264_export_frame_props(h);
    1650       21861 :         if (ret < 0)
    1651           0 :             return ret;
    1652             : 
    1653       21861 :         ret = h264_select_output_frame(h);
    1654       21861 :         if (ret < 0)
    1655           0 :             return ret;
    1656             :     }
    1657             : 
    1658       25098 :     return 0;
    1659             : }
    1660             : 
    1661       31514 : static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
    1662             :                                    const H2645NAL *nal)
    1663             : {
    1664             :     const SPS *sps;
    1665             :     const PPS *pps;
    1666             :     int ret;
    1667             :     unsigned int slice_type, tmp, i;
    1668             :     int field_pic_flag, bottom_field_flag;
    1669       31514 :     int first_slice = sl == h->slice_ctx && !h->current_slice;
    1670             :     int picture_structure;
    1671             : 
    1672       31514 :     if (first_slice)
    1673       25008 :         av_assert0(!h->setup_finished);
    1674             : 
    1675       31514 :     sl->first_mb_addr = get_ue_golomb_long(&sl->gb);
    1676             : 
    1677       31514 :     slice_type = get_ue_golomb_31(&sl->gb);
    1678       31514 :     if (slice_type > 9) {
    1679           0 :         av_log(h->avctx, AV_LOG_ERROR,
    1680             :                "slice type %d too large at %d\n",
    1681             :                slice_type, sl->first_mb_addr);
    1682           0 :         return AVERROR_INVALIDDATA;
    1683             :     }
    1684       31514 :     if (slice_type > 4) {
    1685       19244 :         slice_type -= 5;
    1686       19244 :         sl->slice_type_fixed = 1;
    1687             :     } else
    1688       12270 :         sl->slice_type_fixed = 0;
    1689             : 
    1690       31514 :     slice_type         = ff_h264_golomb_to_pict_type[slice_type];
    1691       31514 :     sl->slice_type     = slice_type;
    1692       31514 :     sl->slice_type_nos = slice_type & 3;
    1693             : 
    1694       33483 :     if (nal->type  == H264_NAL_IDR_SLICE &&
    1695        1969 :         sl->slice_type_nos != AV_PICTURE_TYPE_I) {
    1696           0 :         av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
    1697           0 :         return AVERROR_INVALIDDATA;
    1698             :     }
    1699             : 
    1700       31514 :     sl->pps_id = get_ue_golomb(&sl->gb);
    1701       31514 :     if (sl->pps_id >= MAX_PPS_COUNT) {
    1702           0 :         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
    1703           0 :         return AVERROR_INVALIDDATA;
    1704             :     }
    1705       31514 :     if (!h->ps.pps_list[sl->pps_id]) {
    1706          16 :         av_log(h->avctx, AV_LOG_ERROR,
    1707             :                "non-existing PPS %u referenced\n",
    1708             :                sl->pps_id);
    1709          16 :         return AVERROR_INVALIDDATA;
    1710             :     }
    1711       31498 :     pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
    1712             : 
    1713       31498 :     if (!h->ps.sps_list[pps->sps_id]) {
    1714           0 :         av_log(h->avctx, AV_LOG_ERROR,
    1715             :                "non-existing SPS %u referenced\n", pps->sps_id);
    1716           0 :         return AVERROR_INVALIDDATA;
    1717             :     }
    1718       31498 :     sps = (const SPS*)h->ps.sps_list[pps->sps_id]->data;
    1719             : 
    1720       31498 :     sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
    1721       31498 :     if (!first_slice) {
    1722        6505 :         if (h->poc.frame_num != sl->frame_num) {
    1723           0 :             av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
    1724             :                    h->poc.frame_num, sl->frame_num);
    1725           0 :             return AVERROR_INVALIDDATA;
    1726             :         }
    1727             :     }
    1728             : 
    1729       31498 :     sl->mb_mbaff       = 0;
    1730             : 
    1731       31498 :     if (sps->frame_mbs_only_flag) {
    1732       20159 :         picture_structure = PICT_FRAME;
    1733             :     } else {
    1734       11339 :         if (!sps->direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
    1735           0 :             av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
    1736           0 :             return -1;
    1737             :         }
    1738       11339 :         field_pic_flag = get_bits1(&sl->gb);
    1739       11339 :         if (field_pic_flag) {
    1740        8478 :             bottom_field_flag = get_bits1(&sl->gb);
    1741        8478 :             picture_structure = PICT_TOP_FIELD + bottom_field_flag;
    1742             :         } else {
    1743        2861 :             picture_structure = PICT_FRAME;
    1744             :         }
    1745             :     }
    1746       31498 :     sl->picture_structure      = picture_structure;
    1747       31498 :     sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
    1748             : 
    1749       31498 :     if (picture_structure == PICT_FRAME) {
    1750       23020 :         sl->curr_pic_num = sl->frame_num;
    1751       23020 :         sl->max_pic_num  = 1 << sps->log2_max_frame_num;
    1752             :     } else {
    1753        8478 :         sl->curr_pic_num = 2 * sl->frame_num + 1;
    1754        8478 :         sl->max_pic_num  = 1 << (sps->log2_max_frame_num + 1);
    1755             :     }
    1756             : 
    1757       31498 :     if (nal->type == H264_NAL_IDR_SLICE)
    1758        1969 :         get_ue_golomb_long(&sl->gb); /* idr_pic_id */
    1759             : 
    1760       31498 :     if (sps->poc_type == 0) {
    1761       24482 :         sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
    1762             : 
    1763       24482 :         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
    1764        3430 :             sl->delta_poc_bottom = get_se_golomb(&sl->gb);
    1765             :     }
    1766             : 
    1767       31498 :     if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
    1768        2849 :         sl->delta_poc[0] = get_se_golomb(&sl->gb);
    1769             : 
    1770        2849 :         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
    1771         453 :             sl->delta_poc[1] = get_se_golomb(&sl->gb);
    1772             :     }
    1773             : 
    1774       31498 :     sl->redundant_pic_count = 0;
    1775       31498 :     if (pps->redundant_pic_cnt_present)
    1776           8 :         sl->redundant_pic_count = get_ue_golomb(&sl->gb);
    1777             : 
    1778       31498 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
    1779       11070 :         sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
    1780             : 
    1781       31498 :     ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
    1782             :                                   &sl->gb, pps, sl->slice_type_nos,
    1783       31498 :                                   picture_structure, h->avctx);
    1784       31498 :     if (ret < 0)
    1785           4 :         return ret;
    1786             : 
    1787       31494 :     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
    1788       27373 :        ret = ff_h264_decode_ref_pic_list_reordering(sl, h->avctx);
    1789       27373 :        if (ret < 0) {
    1790           3 :            sl->ref_count[1] = sl->ref_count[0] = 0;
    1791           3 :            return ret;
    1792             :        }
    1793             :     }
    1794             : 
    1795       31491 :     sl->pwt.use_weight = 0;
    1796       94473 :     for (i = 0; i < 2; i++) {
    1797       62982 :         sl->pwt.luma_weight_flag[i]   = 0;
    1798       62982 :         sl->pwt.chroma_weight_flag[i] = 0;
    1799             :     }
    1800       61725 :     if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
    1801       30521 :         (pps->weighted_bipred_idc == 1 &&
    1802         287 :          sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
    1803        1535 :         ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
    1804             :                                   sl->slice_type_nos, &sl->pwt,
    1805        1535 :                                   picture_structure, h->avctx);
    1806        1535 :         if (ret < 0)
    1807           0 :             return ret;
    1808             :     }
    1809             : 
    1810       31491 :     sl->explicit_ref_marking = 0;
    1811       31491 :     if (nal->ref_idc) {
    1812       20721 :         ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx);
    1813       20721 :         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    1814           0 :             return AVERROR_INVALIDDATA;
    1815             :     }
    1816             : 
    1817       31491 :     if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
    1818       13226 :         tmp = get_ue_golomb_31(&sl->gb);
    1819       13226 :         if (tmp > 2) {
    1820           0 :             av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
    1821           0 :             return AVERROR_INVALIDDATA;
    1822             :         }
    1823       13226 :         sl->cabac_init_idc = tmp;
    1824             :     }
    1825             : 
    1826       31491 :     sl->last_qscale_diff = 0;
    1827       31491 :     tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
    1828       31491 :     if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
    1829           0 :         av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
    1830           0 :         return AVERROR_INVALIDDATA;
    1831             :     }
    1832       31491 :     sl->qscale       = tmp;
    1833       31491 :     sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
    1834       31491 :     sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
    1835             :     // FIXME qscale / qp ... stuff
    1836       31491 :     if (sl->slice_type == AV_PICTURE_TYPE_SP)
    1837           0 :         get_bits1(&sl->gb); /* sp_for_switch_flag */
    1838       62982 :     if (sl->slice_type == AV_PICTURE_TYPE_SP ||
    1839       31491 :         sl->slice_type == AV_PICTURE_TYPE_SI)
    1840           0 :         get_se_golomb(&sl->gb); /* slice_qs_delta */
    1841             : 
    1842       31491 :     sl->deblocking_filter     = 1;
    1843       31491 :     sl->slice_alpha_c0_offset = 0;
    1844       31491 :     sl->slice_beta_offset     = 0;
    1845       31491 :     if (pps->deblocking_filter_parameters_present) {
    1846       17225 :         tmp = get_ue_golomb_31(&sl->gb);
    1847       17225 :         if (tmp > 2) {
    1848           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1849             :                    "deblocking_filter_idc %u out of range\n", tmp);
    1850           0 :             return AVERROR_INVALIDDATA;
    1851             :         }
    1852       17225 :         sl->deblocking_filter = tmp;
    1853       17225 :         if (sl->deblocking_filter < 2)
    1854       17128 :             sl->deblocking_filter ^= 1;  // 1<->0
    1855             : 
    1856       17225 :         if (sl->deblocking_filter) {
    1857       10290 :             int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
    1858       10290 :             int slice_beta_offset_div2     = get_se_golomb(&sl->gb);
    1859       10290 :             if (slice_alpha_c0_offset_div2 >  6 ||
    1860       10290 :                 slice_alpha_c0_offset_div2 < -6 ||
    1861       10290 :                 slice_beta_offset_div2 >  6     ||
    1862             :                 slice_beta_offset_div2 < -6) {
    1863           0 :                 av_log(h->avctx, AV_LOG_ERROR,
    1864             :                        "deblocking filter parameters %d %d out of range\n",
    1865             :                        slice_alpha_c0_offset_div2, slice_beta_offset_div2);
    1866           0 :                 return AVERROR_INVALIDDATA;
    1867             :             }
    1868       10290 :             sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
    1869       10290 :             sl->slice_beta_offset     = slice_beta_offset_div2 * 2;
    1870             :         }
    1871             :     }
    1872             : 
    1873       31491 :     return 0;
    1874             : }
    1875             : 
    1876             : /* do all the per-slice initialization needed before we can start decoding the
    1877             :  * actual MBs */
    1878       31410 : static int h264_slice_init(H264Context *h, H264SliceContext *sl,
    1879             :                            const H2645NAL *nal)
    1880             : {
    1881       31410 :     int i, j, ret = 0;
    1882             : 
    1883       31410 :     if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
    1884           0 :         av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
    1885           0 :         return AVERROR_INVALIDDATA;
    1886             :     }
    1887             : 
    1888             :     av_assert1(h->mb_num == h->mb_width * h->mb_height);
    1889       62820 :     if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
    1890       31410 :         sl->first_mb_addr >= h->mb_num) {
    1891           0 :         av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
    1892           0 :         return AVERROR_INVALIDDATA;
    1893             :     }
    1894       31410 :     sl->resync_mb_x = sl->mb_x =  sl->first_mb_addr % h->mb_width;
    1895       62820 :     sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
    1896       31410 :                                  FIELD_OR_MBAFF_PICTURE(h);
    1897       31410 :     if (h->picture_structure == PICT_BOTTOM_FIELD)
    1898        4197 :         sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
    1899             :     av_assert1(sl->mb_y < h->mb_height);
    1900             : 
    1901       31410 :     ret = ff_h264_build_ref_list(h, sl);
    1902       31410 :     if (ret < 0)
    1903           0 :         return ret;
    1904             : 
    1905       32587 :     if (h->ps.pps->weighted_bipred_idc == 2 &&
    1906        1177 :         sl->slice_type_nos == AV_PICTURE_TYPE_B) {
    1907         732 :         implicit_weight_table(h, sl, -1);
    1908         732 :         if (FRAME_MBAFF(h)) {
    1909          11 :             implicit_weight_table(h, sl, 0);
    1910          11 :             implicit_weight_table(h, sl, 1);
    1911             :         }
    1912             :     }
    1913             : 
    1914       31410 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
    1915        7703 :         ff_h264_direct_dist_scale_factor(h, sl);
    1916       31410 :     if (!h->setup_finished)
    1917       31410 :         ff_h264_direct_ref_list_init(h, sl);
    1918             : 
    1919       62820 :     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
    1920       31410 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
    1921       31410 :          h->nal_unit_type != H264_NAL_IDR_SLICE) ||
    1922       31410 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
    1923       31410 :          sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
    1924       31410 :         (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR  &&
    1925       31410 :          sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
    1926       31410 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
    1927           0 :          nal->ref_idc == 0))
    1928           0 :         sl->deblocking_filter = 0;
    1929             : 
    1930       31410 :     if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
    1931           0 :         if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
    1932             :             /* Cheat slightly for speed:
    1933             :              * Do not bother to deblock across slices. */
    1934           0 :             sl->deblocking_filter = 2;
    1935             :         } else {
    1936           0 :             h->postpone_filter = 1;
    1937             :         }
    1938             :     }
    1939       62820 :     sl->qp_thresh = 15 -
    1940       62820 :                    FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
    1941       31410 :                    FFMAX3(0,
    1942             :                           h->ps.pps->chroma_qp_index_offset[0],
    1943       31410 :                           h->ps.pps->chroma_qp_index_offset[1]) +
    1944       31410 :                    6 * (h->ps.sps->bit_depth_luma - 8);
    1945             : 
    1946       31410 :     sl->slice_num       = ++h->current_slice;
    1947             : 
    1948       31410 :     if (sl->slice_num)
    1949       31410 :         h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
    1950       31410 :     if (   h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
    1951       29346 :         && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
    1952       23325 :         && sl->slice_num >= MAX_SLICES) {
    1953             :         //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
    1954           0 :         av_log(h->avctx, AV_LOG_WARNING, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", sl->slice_num, MAX_SLICES);
    1955             :     }
    1956             : 
    1957       94230 :     for (j = 0; j < 2; j++) {
    1958             :         int id_list[16];
    1959       62820 :         int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
    1960     1067940 :         for (i = 0; i < 16; i++) {
    1961     1005120 :             id_list[i] = 60;
    1962     1131297 :             if (j < sl->list_count && i < sl->ref_count[j] &&
    1963      126177 :                 sl->ref_list[j][i].parent->f->buf[0]) {
    1964             :                 int k;
    1965      126177 :                 AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
    1966      445644 :                 for (k = 0; k < h->short_ref_count; k++)
    1967      443695 :                     if (h->short_ref[k]->f->buf[0]->buffer == buf) {
    1968      124228 :                         id_list[i] = k;
    1969      124228 :                         break;
    1970             :                     }
    1971      136293 :                 for (k = 0; k < h->long_ref_count; k++)
    1972       11870 :                     if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
    1973        1754 :                         id_list[i] = h->short_ref_count + k;
    1974        1754 :                         break;
    1975             :                     }
    1976             :             }
    1977             :         }
    1978             : 
    1979       62820 :         ref2frm[0] =
    1980       62820 :         ref2frm[1] = -1;
    1981     1067940 :         for (i = 0; i < 16; i++)
    1982     1005120 :             ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
    1983      125640 :         ref2frm[18 + 0] =
    1984      125640 :         ref2frm[18 + 1] = -1;
    1985     2073060 :         for (i = 16; i < 48; i++)
    1986     4020480 :             ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
    1987     2010240 :                              (sl->ref_list[j][i].reference & 3);
    1988             :     }
    1989             : 
    1990       31410 :     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
    1991           0 :         av_log(h->avctx, AV_LOG_DEBUG,
    1992             :                "slice:%d %s mb:%d %c%s%s frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
    1993             :                sl->slice_num,
    1994           0 :                (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
    1995           0 :                sl->mb_y * h->mb_width + sl->mb_x,
    1996           0 :                av_get_picture_type_char(sl->slice_type),
    1997           0 :                sl->slice_type_fixed ? " fix" : "",
    1998           0 :                nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
    1999             :                h->poc.frame_num,
    2000           0 :                h->cur_pic_ptr->field_poc[0],
    2001           0 :                h->cur_pic_ptr->field_poc[1],
    2002             :                sl->ref_count[0], sl->ref_count[1],
    2003             :                sl->qscale,
    2004             :                sl->deblocking_filter,
    2005             :                sl->slice_alpha_c0_offset, sl->slice_beta_offset,
    2006             :                sl->pwt.use_weight,
    2007           0 :                sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
    2008           0 :                sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
    2009             :     }
    2010             : 
    2011       31410 :     return 0;
    2012             : }
    2013             : 
    2014       31514 : int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
    2015             : {
    2016       31514 :     H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
    2017       31514 :     int first_slice = sl == h->slice_ctx && !h->current_slice;
    2018             :     int ret;
    2019             : 
    2020       31514 :     sl->gb = nal->gb;
    2021             : 
    2022       31514 :     ret = h264_slice_header_parse(h, sl, nal);
    2023       31514 :     if (ret < 0)
    2024          23 :         return ret;
    2025             : 
    2026             :     // discard redundant pictures
    2027       31491 :     if (sl->redundant_pic_count > 0) {
    2028           1 :         sl->ref_count[0] = sl->ref_count[1] = 0;
    2029           1 :         return 0;
    2030             :     }
    2031             : 
    2032       31490 :     if (sl->first_mb_addr == 0 || !h->current_slice) {
    2033       25178 :         if (h->setup_finished) {
    2034           0 :             av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
    2035           0 :             return AVERROR_INVALIDDATA;
    2036             :         }
    2037             :     }
    2038             : 
    2039       31490 :     if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
    2040       25175 :         if (h->current_slice) {
    2041             :             // this slice starts a new field
    2042             :             // first decode any pending queued slices
    2043         193 :             if (h->nb_slice_ctx_queued) {
    2044             :                 H264SliceContext tmp_ctx;
    2045             : 
    2046           0 :                 ret = ff_h264_execute_decode_slices(h);
    2047           0 :                 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    2048           0 :                     return ret;
    2049             : 
    2050           0 :                 memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
    2051           0 :                 memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
    2052           0 :                 memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
    2053           0 :                 sl = h->slice_ctx;
    2054             :             }
    2055             : 
    2056         193 :             if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
    2057         193 :                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
    2058         386 :                 if (ret < 0)
    2059           0 :                     return ret;
    2060           0 :             } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type  == H264_NAL_IDR_SLICE) {
    2061           0 :                 av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
    2062           0 :                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
    2063           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
    2064           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
    2065           0 :                 h->cur_pic_ptr = NULL;
    2066           0 :                 if (ret < 0)
    2067           0 :                     return ret;
    2068             :             } else
    2069           0 :                 return AVERROR_INVALIDDATA;
    2070             :         }
    2071             : 
    2072       25175 :         if (!h->first_field) {
    2073       21941 :             if (h->cur_pic_ptr && !h->droppable) {
    2074           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    2075           0 :                                           h->picture_structure == PICT_BOTTOM_FIELD);
    2076             :             }
    2077       21941 :             h->cur_pic_ptr = NULL;
    2078             :         }
    2079             :     }
    2080             : 
    2081       31490 :     if (!h->current_slice)
    2082       25178 :         av_assert0(sl == h->slice_ctx);
    2083             : 
    2084       31490 :     if (h->current_slice == 0 && !h->first_field) {
    2085       21944 :         if (
    2086       43972 :             (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
    2087       43928 :             (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
    2088       43804 :             (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
    2089       43730 :             (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
    2090       21864 :             h->avctx->skip_frame >= AVDISCARD_ALL) {
    2091          80 :             return 0;
    2092             :         }
    2093             :     }
    2094             : 
    2095       31410 :     if (!first_slice) {
    2096        6505 :         const PPS *pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
    2097             : 
    2098       13010 :         if (h->ps.pps->sps_id != pps->sps_id ||
    2099        6505 :             h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
    2100             :             (h->setup_finished && h->ps.pps != pps)*/) {
    2101           0 :             av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
    2102           0 :             return AVERROR_INVALIDDATA;
    2103             :         }
    2104        6505 :         if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
    2105           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2106             :                "SPS changed in the middle of the frame\n");
    2107           0 :             return AVERROR_INVALIDDATA;
    2108             :         }
    2109             :     }
    2110             : 
    2111       31410 :     if (h->current_slice == 0) {
    2112       25098 :         ret = h264_field_start(h, sl, nal, first_slice);
    2113       25098 :         if (ret < 0)
    2114           0 :             return ret;
    2115             :     } else {
    2116       12624 :         if (h->picture_structure != sl->picture_structure ||
    2117        6312 :             h->droppable         != (nal->ref_idc == 0)) {
    2118           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2119             :                    "Changing field mode (%d -> %d) between slices is not allowed\n",
    2120             :                    h->picture_structure, sl->picture_structure);
    2121           0 :             return AVERROR_INVALIDDATA;
    2122        6312 :         } else if (!h->cur_pic_ptr) {
    2123           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2124             :                    "unset cur_pic_ptr on slice %d\n",
    2125           0 :                    h->current_slice + 1);
    2126           0 :             return AVERROR_INVALIDDATA;
    2127             :         }
    2128             :     }
    2129             : 
    2130       31410 :     ret = h264_slice_init(h, sl, nal);
    2131       31410 :     if (ret < 0)
    2132           0 :         return ret;
    2133             : 
    2134       31410 :     h->nb_slice_ctx_queued++;
    2135             : 
    2136       31410 :     return 0;
    2137             : }
    2138             : 
    2139           0 : int ff_h264_get_slice_type(const H264SliceContext *sl)
    2140             : {
    2141           0 :     switch (sl->slice_type) {
    2142           0 :     case AV_PICTURE_TYPE_P:
    2143           0 :         return 0;
    2144           0 :     case AV_PICTURE_TYPE_B:
    2145           0 :         return 1;
    2146           0 :     case AV_PICTURE_TYPE_I:
    2147           0 :         return 2;
    2148           0 :     case AV_PICTURE_TYPE_SP:
    2149           0 :         return 3;
    2150           0 :     case AV_PICTURE_TYPE_SI:
    2151           0 :         return 4;
    2152           0 :     default:
    2153           0 :         return AVERROR_INVALIDDATA;
    2154             :     }
    2155             : }
    2156             : 
    2157    10228264 : static av_always_inline void fill_filter_caches_inter(const H264Context *h,
    2158             :                                                       H264SliceContext *sl,
    2159             :                                                       int mb_type, int top_xy,
    2160             :                                                       int left_xy[LEFT_MBS],
    2161             :                                                       int top_type,
    2162             :                                                       int left_type[LEFT_MBS],
    2163             :                                                       int mb_xy, int list)
    2164             : {
    2165    10228264 :     int b_stride = h->b_stride;
    2166    10228264 :     int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
    2167    10228264 :     int8_t *ref_cache   = &sl->ref_cache[list][scan8[0]];
    2168    10228264 :     if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
    2169    10228264 :         if (USES_LIST(top_type, list)) {
    2170     8138576 :             const int b_xy  = h->mb2b_xy[top_xy] + 3 * b_stride;
    2171     8138576 :             const int b8_xy = 4 * top_xy + 2;
    2172     8138576 :             const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2173     8138576 :             AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
    2174    16277152 :             ref_cache[0 - 1 * 8] =
    2175    16277152 :             ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
    2176    16277152 :             ref_cache[2 - 1 * 8] =
    2177    16277152 :             ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
    2178             :         } else {
    2179     2089688 :             AV_ZERO128(mv_dst - 1 * 8);
    2180     2089688 :             AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2181             :         }
    2182             : 
    2183    10228264 :         if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
    2184     9828673 :             if (USES_LIST(left_type[LTOP], list)) {
    2185     8123456 :                 const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
    2186     8123456 :                 const int b8_xy = 4 * left_xy[LTOP] + 1;
    2187     8123456 :                 const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2188     8123456 :                 AV_COPY32(mv_dst - 1 +  0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
    2189     8123456 :                 AV_COPY32(mv_dst - 1 +  8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
    2190     8123456 :                 AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
    2191     8123456 :                 AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
    2192    16246912 :                 ref_cache[-1 +  0] =
    2193    16246912 :                 ref_cache[-1 +  8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
    2194    16246912 :                 ref_cache[-1 + 16] =
    2195    16246912 :                 ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
    2196             :             } else {
    2197     1705217 :                 AV_ZERO32(mv_dst - 1 +  0);
    2198     1705217 :                 AV_ZERO32(mv_dst - 1 +  8);
    2199     1705217 :                 AV_ZERO32(mv_dst - 1 + 16);
    2200     1705217 :                 AV_ZERO32(mv_dst - 1 + 24);
    2201     3410434 :                 ref_cache[-1 +  0] =
    2202     5115651 :                 ref_cache[-1 +  8] =
    2203     5115651 :                 ref_cache[-1 + 16] =
    2204     3410434 :                 ref_cache[-1 + 24] = LIST_NOT_USED;
    2205             :             }
    2206             :         }
    2207             :     }
    2208             : 
    2209    10228264 :     if (!USES_LIST(mb_type, list)) {
    2210     1187477 :         fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
    2211     1187477 :         AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2212     1187477 :         AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2213     1187477 :         AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2214     1187477 :         AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2215     1187477 :         return;
    2216             :     }
    2217             : 
    2218             :     {
    2219     9040787 :         int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
    2220     9040787 :         const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2221     9040787 :         uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
    2222     9040787 :         uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
    2223     9040787 :         AV_WN32A(&ref_cache[0 * 8], ref01);
    2224     9040787 :         AV_WN32A(&ref_cache[1 * 8], ref01);
    2225     9040787 :         AV_WN32A(&ref_cache[2 * 8], ref23);
    2226     9040787 :         AV_WN32A(&ref_cache[3 * 8], ref23);
    2227             :     }
    2228             : 
    2229             :     {
    2230     9040787 :         int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
    2231     9040787 :         AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
    2232     9040787 :         AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
    2233     9040787 :         AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
    2234     9040787 :         AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
    2235             :     }
    2236             : }
    2237             : 
    2238             : /**
    2239             :  * @return non zero if the loop filter can be skipped
    2240             :  */
    2241    10343344 : static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
    2242             : {
    2243    10343344 :     const int mb_xy = sl->mb_xy;
    2244             :     int top_xy, left_xy[LEFT_MBS];
    2245             :     int top_type, left_type[LEFT_MBS];
    2246             :     uint8_t *nnz;
    2247             :     uint8_t *nnz_cache;
    2248             : 
    2249    10343344 :     top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
    2250             : 
    2251    10343344 :     left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
    2252    10343344 :     if (FRAME_MBAFF(h)) {
    2253     1576140 :         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
    2254     1576140 :         const int curr_mb_field_flag = IS_INTERLACED(mb_type);
    2255     1576140 :         if (sl->mb_y & 1) {
    2256      788070 :             if (left_mb_field_flag != curr_mb_field_flag)
    2257      189266 :                 left_xy[LTOP] -= h->mb_stride;
    2258             :         } else {
    2259      788070 :             if (curr_mb_field_flag)
    2260      482514 :                 top_xy += h->mb_stride &
    2261      241257 :                           (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
    2262      788070 :             if (left_mb_field_flag != curr_mb_field_flag)
    2263      189266 :                 left_xy[LBOT] += h->mb_stride;
    2264             :         }
    2265             :     }
    2266             : 
    2267    10343344 :     sl->top_mb_xy        = top_xy;
    2268    10343344 :     sl->left_mb_xy[LTOP] = left_xy[LTOP];
    2269    10343344 :     sl->left_mb_xy[LBOT] = left_xy[LBOT];
    2270             :     {
    2271             :         /* For sufficiently low qp, filtering wouldn't do anything.
    2272             :          * This is a conservative estimate: could also check beta_offset
    2273             :          * and more accurate chroma_qp. */
    2274    10343344 :         int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
    2275    10343344 :         int qp        = h->cur_pic.qscale_table[mb_xy];
    2276    11331155 :         if (qp <= qp_thresh &&
    2277     1974830 :             (left_xy[LTOP] < 0 ||
    2278     1911044 :              ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
    2279      884887 :             (top_xy < 0 ||
    2280      884887 :              ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
    2281      859122 :             if (!FRAME_MBAFF(h))
    2282      636677 :                 return 1;
    2283      444796 :             if ((left_xy[LTOP] < 0 ||
    2284      444391 :                  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
    2285      429509 :                 (top_xy < h->mb_stride ||
    2286      207469 :                  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
    2287      205646 :                 return 1;
    2288             :         }
    2289             :     }
    2290             : 
    2291     9501021 :     top_type        = h->cur_pic.mb_type[top_xy];
    2292     9501021 :     left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
    2293     9501021 :     left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
    2294     9501021 :     if (sl->deblocking_filter == 2) {
    2295      232380 :         if (h->slice_table[top_xy] != sl->slice_num)
    2296        3990 :             top_type = 0;
    2297      232380 :         if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
    2298        3056 :             left_type[LTOP] = left_type[LBOT] = 0;
    2299             :     } else {
    2300     9268641 :         if (h->slice_table[top_xy] == 0xFFFF)
    2301      443618 :             top_type = 0;
    2302     9268641 :         if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
    2303      285573 :             left_type[LTOP] = left_type[LBOT] = 0;
    2304             :     }
    2305     9501021 :     sl->top_type        = top_type;
    2306     9501021 :     sl->left_type[LTOP] = left_type[LTOP];
    2307     9501021 :     sl->left_type[LBOT] = left_type[LBOT];
    2308             : 
    2309     9501021 :     if (IS_INTRA(mb_type))
    2310     2811864 :         return 0;
    2311             : 
    2312     6689157 :     fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
    2313             :                              top_type, left_type, mb_xy, 0);
    2314     6689157 :     if (sl->list_count == 2)
    2315     3539107 :         fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
    2316             :                                  top_type, left_type, mb_xy, 1);
    2317             : 
    2318     6689157 :     nnz       = h->non_zero_count[mb_xy];
    2319     6689157 :     nnz_cache = sl->non_zero_count_cache;
    2320     6689157 :     AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
    2321     6689157 :     AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
    2322     6689157 :     AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
    2323     6689157 :     AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
    2324     6689157 :     sl->cbp = h->cbp_table[mb_xy];
    2325             : 
    2326     6689157 :     if (top_type) {
    2327     6338852 :         nnz = h->non_zero_count[top_xy];
    2328     6338852 :         AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
    2329             :     }
    2330             : 
    2331     6689157 :     if (left_type[LTOP]) {
    2332     6454395 :         nnz = h->non_zero_count[left_xy[LTOP]];
    2333     6454395 :         nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
    2334     6454395 :         nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
    2335     6454395 :         nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
    2336     6454395 :         nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
    2337             :     }
    2338             : 
    2339             :     /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
    2340             :      * from what the loop filter needs */
    2341     6689157 :     if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
    2342      246512 :         if (IS_8x8DCT(top_type)) {
    2343      215760 :             nnz_cache[4 + 8 * 0] =
    2344      215760 :             nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
    2345      215760 :             nnz_cache[6 + 8 * 0] =
    2346      215760 :             nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
    2347             :         }
    2348      246512 :         if (IS_8x8DCT(left_type[LTOP])) {
    2349      220912 :             nnz_cache[3 + 8 * 1] =
    2350      220912 :             nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
    2351             :         }
    2352      246512 :         if (IS_8x8DCT(left_type[LBOT])) {
    2353      221112 :             nnz_cache[3 + 8 * 3] =
    2354      221112 :             nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
    2355             :         }
    2356             : 
    2357      246512 :         if (IS_8x8DCT(mb_type)) {
    2358      209846 :             nnz_cache[scan8[0]] =
    2359      314769 :             nnz_cache[scan8[1]] =
    2360      314769 :             nnz_cache[scan8[2]] =
    2361      209846 :             nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
    2362             : 
    2363      209846 :             nnz_cache[scan8[0 + 4]] =
    2364      314769 :             nnz_cache[scan8[1 + 4]] =
    2365      314769 :             nnz_cache[scan8[2 + 4]] =
    2366      209846 :             nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
    2367             : 
    2368      209846 :             nnz_cache[scan8[0 + 8]] =
    2369      314769 :             nnz_cache[scan8[1 + 8]] =
    2370      314769 :             nnz_cache[scan8[2 + 8]] =
    2371      209846 :             nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
    2372             : 
    2373      209846 :             nnz_cache[scan8[0 + 12]] =
    2374      314769 :             nnz_cache[scan8[1 + 12]] =
    2375      314769 :             nnz_cache[scan8[2 + 12]] =
    2376      209846 :             nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
    2377             :         }
    2378             :     }
    2379             : 
    2380     6689157 :     return 0;
    2381             : }
    2382             : 
    2383      349343 : static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
    2384             : {
    2385             :     uint8_t *dest_y, *dest_cb, *dest_cr;
    2386             :     int linesize, uvlinesize, mb_x, mb_y;
    2387      349343 :     const int end_mb_y       = sl->mb_y + FRAME_MBAFF(h);
    2388      349343 :     const int old_slice_type = sl->slice_type;
    2389      349343 :     const int pixel_shift    = h->pixel_shift;
    2390      349343 :     const int block_h        = 16 >> h->chroma_y_shift;
    2391             : 
    2392      349343 :     if (h->postpone_filter)
    2393           0 :         return;
    2394             : 
    2395      349343 :     if (sl->deblocking_filter) {
    2396     9835455 :         for (mb_x = start_x; mb_x < end_x; mb_x++)
    2397    19898618 :             for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
    2398             :                 int mb_xy, mb_type;
    2399    10343344 :                 mb_xy         = sl->mb_xy = mb_x + mb_y * h->mb_stride;
    2400    10343344 :                 mb_type       = h->cur_pic.mb_type[mb_xy];
    2401             : 
    2402    10343344 :                 if (FRAME_MBAFF(h))
    2403     1576140 :                     sl->mb_mbaff               =
    2404     1576140 :                     sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
    2405             : 
    2406    10343344 :                 sl->mb_x = mb_x;
    2407    10343344 :                 sl->mb_y = mb_y;
    2408    20686688 :                 dest_y  = h->cur_pic.f->data[0] +
    2409    10343344 :                           ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
    2410    20686688 :                 dest_cb = h->cur_pic.f->data[1] +
    2411    20686688 :                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
    2412    10343344 :                           mb_y * sl->uvlinesize * block_h;
    2413    20686688 :                 dest_cr = h->cur_pic.f->data[2] +
    2414    20686688 :                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
    2415    10343344 :                           mb_y * sl->uvlinesize * block_h;
    2416             :                 // FIXME simplify above
    2417             : 
    2418    10343344 :                 if (MB_FIELD(sl)) {
    2419     3606600 :                     linesize   = sl->mb_linesize   = sl->linesize   * 2;
    2420     3606600 :                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
    2421     3606600 :                     if (mb_y & 1) { // FIXME move out of this function?
    2422     1802625 :                         dest_y  -= sl->linesize   * 15;
    2423     1802625 :                         dest_cb -= sl->uvlinesize * (block_h - 1);
    2424     1802625 :                         dest_cr -= sl->uvlinesize * (block_h - 1);
    2425             :                     }
    2426             :                 } else {
    2427     6736744 :                     linesize   = sl->mb_linesize   = sl->linesize;
    2428     6736744 :                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
    2429             :                 }
    2430    10343344 :                 backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
    2431             :                                  uvlinesize, 0);
    2432    10343344 :                 if (fill_filter_caches(h, sl, mb_type))
    2433      842323 :                     continue;
    2434     9501021 :                 sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
    2435     9501021 :                 sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
    2436             : 
    2437     9501021 :                 if (FRAME_MBAFF(h)) {
    2438     1370494 :                     ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
    2439             :                                       linesize, uvlinesize);
    2440             :                 } else {
    2441     8130527 :                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
    2442             :                                            dest_cr, linesize, uvlinesize);
    2443             :                 }
    2444             :             }
    2445             :     }
    2446      349343 :     sl->slice_type  = old_slice_type;
    2447      349343 :     sl->mb_x         = end_x;
    2448      349343 :     sl->mb_y         = end_mb_y - FRAME_MBAFF(h);
    2449      349343 :     sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
    2450      349343 :     sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
    2451             : }
    2452             : 
    2453       18076 : static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
    2454             : {
    2455       18076 :     const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
    2456       36152 :     int mb_type     = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
    2457       54092 :                       h->cur_pic.mb_type[mb_xy - 1] :
    2458       18076 :                       (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
    2459       17940 :                       h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
    2460       18076 :     sl->mb_mbaff    = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
    2461       18076 : }
    2462             : 
    2463             : /**
    2464             :  * Draw edges and report progress for the last MB row.
    2465             :  */
    2466      345246 : static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
    2467             : {
    2468      345246 :     int top            = 16 * (sl->mb_y      >> FIELD_PICTURE(h));
    2469      345246 :     int pic_height     = 16 *  h->mb_height >> FIELD_PICTURE(h);
    2470      345246 :     int height         =  16      << FRAME_MBAFF(h);
    2471      345246 :     int deblock_border = (16 + 4) << FRAME_MBAFF(h);
    2472             : 
    2473      345246 :     if (sl->deblocking_filter) {
    2474      277096 :         if ((top + height) >= pic_height)
    2475       19511 :             height += deblock_border;
    2476      277096 :         top -= deblock_border;
    2477             :     }
    2478             : 
    2479      345246 :     if (top >= pic_height || (top + height) < 0)
    2480       19520 :         return;
    2481             : 
    2482      325726 :     height = FFMIN(height, pic_height - top);
    2483      325726 :     if (top < 0) {
    2484       19516 :         height = top + height;
    2485       19516 :         top    = 0;
    2486             :     }
    2487             : 
    2488      325726 :     ff_h264_draw_horiz_band(h, sl, top, height);
    2489             : 
    2490      325726 :     if (h->droppable || sl->h264->slice_ctx[0].er.error_occurred)
    2491      118239 :         return;
    2492             : 
    2493      207487 :     ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
    2494      207487 :                               h->picture_structure == PICT_BOTTOM_FIELD);
    2495             : }
    2496             : 
    2497       31410 : static void er_add_slice(H264SliceContext *sl,
    2498             :                          int startx, int starty,
    2499             :                          int endx, int endy, int status)
    2500             : {
    2501       31410 :     if (!sl->h264->enable_er)
    2502           0 :         return;
    2503             : 
    2504             :     if (CONFIG_ERROR_RESILIENCE) {
    2505       31410 :         ERContext *er = &sl->h264->slice_ctx[0].er;
    2506             : 
    2507       31410 :         ff_er_add_slice(er, startx, starty, endx, endy, status);
    2508             :     }
    2509             : }
    2510             : 
    2511       31410 : static int decode_slice(struct AVCodecContext *avctx, void *arg)
    2512             : {
    2513       31410 :     H264SliceContext *sl = arg;
    2514       31410 :     const H264Context *h = sl->h264;
    2515       31410 :     int lf_x_start = sl->mb_x;
    2516       31410 :     int orig_deblock = sl->deblocking_filter;
    2517             :     int ret;
    2518             : 
    2519       31410 :     sl->linesize   = h->cur_pic_ptr->f->linesize[0];
    2520       31410 :     sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
    2521             : 
    2522       31410 :     ret = alloc_scratch_buffers(sl, sl->linesize);
    2523       31410 :     if (ret < 0)
    2524           0 :         return ret;
    2525             : 
    2526       31410 :     sl->mb_skip_run = -1;
    2527             : 
    2528       31410 :     av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
    2529             : 
    2530       31410 :     if (h->postpone_filter)
    2531           0 :         sl->deblocking_filter = 0;
    2532             : 
    2533       31410 :     sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
    2534             :                      (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
    2535             : 
    2536       31410 :     if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && h->slice_ctx[0].er.error_status_table) {
    2537       23012 :         const int start_i  = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
    2538       23012 :         if (start_i) {
    2539        4388 :             int prev_status = h->slice_ctx[0].er.error_status_table[h->slice_ctx[0].er.mb_index2xy[start_i - 1]];
    2540        4388 :             prev_status &= ~ VP_START;
    2541        4388 :             if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
    2542          13 :                 h->slice_ctx[0].er.error_occurred = 1;
    2543             :         }
    2544             :     }
    2545             : 
    2546       31410 :     if (h->ps.pps->cabac) {
    2547             :         /* realign */
    2548       15486 :         align_get_bits(&sl->gb);
    2549             : 
    2550             :         /* init cabac */
    2551       30972 :         ret = ff_init_cabac_decoder(&sl->cabac,
    2552       15486 :                               sl->gb.buffer + get_bits_count(&sl->gb) / 8,
    2553       15486 :                               (get_bits_left(&sl->gb) + 7) / 8);
    2554       15486 :         if (ret < 0)
    2555           0 :             return ret;
    2556             : 
    2557       15486 :         ff_h264_init_cabac_states(h, sl);
    2558             : 
    2559     7391340 :         for (;;) {
    2560             :             // START_TIMER
    2561             :             int ret, eos;
    2562     7406826 :             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
    2563           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
    2564             :                        sl->next_slice_idx);
    2565           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2566             :                              sl->mb_y, ER_MB_ERROR);
    2567           0 :                 return AVERROR_INVALIDDATA;
    2568             :             }
    2569             : 
    2570     7406826 :             ret = ff_h264_decode_mb_cabac(h, sl);
    2571             :             // STOP_TIMER("decode_mb_cabac")
    2572             : 
    2573     7406826 :             if (ret >= 0)
    2574     7406826 :                 ff_h264_hl_decode_mb(h, sl);
    2575             : 
    2576             :             // FIXME optimal? or let mb_decode decode 16x32 ?
    2577     7406826 :             if (ret >= 0 && FRAME_MBAFF(h)) {
    2578      679722 :                 sl->mb_y++;
    2579             : 
    2580      679722 :                 ret = ff_h264_decode_mb_cabac(h, sl);
    2581             : 
    2582      679722 :                 if (ret >= 0)
    2583      679722 :                     ff_h264_hl_decode_mb(h, sl);
    2584      679722 :                 sl->mb_y--;
    2585             :             }
    2586     7406826 :             eos = get_cabac_terminate(&sl->cabac);
    2587             : 
    2588     7406826 :             if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
    2589           0 :                 sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
    2590           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
    2591             :                              sl->mb_y, ER_MB_END);
    2592           0 :                 if (sl->mb_x >= lf_x_start)
    2593           0 :                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
    2594           0 :                 goto finish;
    2595             :             }
    2596     7406826 :             if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
    2597           1 :                 av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
    2598     7406826 :             if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
    2599           2 :                 av_log(h->avctx, AV_LOG_ERROR,
    2600             :                        "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
    2601             :                        sl->mb_x, sl->mb_y,
    2602           2 :                        sl->cabac.bytestream_end - sl->cabac.bytestream);
    2603           1 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2604             :                              sl->mb_y, ER_MB_ERROR);
    2605           1 :                 return AVERROR_INVALIDDATA;
    2606             :             }
    2607             : 
    2608     7406825 :             if (++sl->mb_x >= h->mb_width) {
    2609      192751 :                 loop_filter(h, sl, lf_x_start, sl->mb_x);
    2610      192751 :                 sl->mb_x = lf_x_start = 0;
    2611      192751 :                 decode_finish_row(h, sl);
    2612      192751 :                 ++sl->mb_y;
    2613      192751 :                 if (FIELD_OR_MBAFF_PICTURE(h)) {
    2614       64653 :                     ++sl->mb_y;
    2615       64653 :                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
    2616       13098 :                         predict_field_decoding_flag(h, sl);
    2617             :                 }
    2618             :             }
    2619             : 
    2620     7406825 :             if (eos || sl->mb_y >= h->mb_height) {
    2621             :                 ff_tlog(h->avctx, "slice end %d %d\n",
    2622             :                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2623       15485 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
    2624             :                              sl->mb_y, ER_MB_END);
    2625       15485 :                 if (sl->mb_x > lf_x_start)
    2626        1382 :                     loop_filter(h, sl, lf_x_start, sl->mb_x);
    2627       15485 :                 goto finish;
    2628             :             }
    2629             :         }
    2630             :     } else {
    2631     4073493 :         for (;;) {
    2632             :             int ret;
    2633             : 
    2634     4089417 :             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
    2635           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
    2636             :                        sl->next_slice_idx);
    2637           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2638             :                              sl->mb_y, ER_MB_ERROR);
    2639           0 :                 return AVERROR_INVALIDDATA;
    2640             :             }
    2641             : 
    2642     4089417 :             ret = ff_h264_decode_mb_cavlc(h, sl);
    2643             : 
    2644     4089417 :             if (ret >= 0)
    2645     4089403 :                 ff_h264_hl_decode_mb(h, sl);
    2646             : 
    2647             :             // FIXME optimal? or let mb_decode decode 16x32 ?
    2648     4089417 :             if (ret >= 0 && FRAME_MBAFF(h)) {
    2649      254472 :                 sl->mb_y++;
    2650      254472 :                 ret = ff_h264_decode_mb_cavlc(h, sl);
    2651             : 
    2652      254472 :                 if (ret >= 0)
    2653      254472 :                     ff_h264_hl_decode_mb(h, sl);
    2654      254472 :                 sl->mb_y--;
    2655             :             }
    2656             : 
    2657     4089417 :             if (ret < 0) {
    2658          14 :                 av_log(h->avctx, AV_LOG_ERROR,
    2659             :                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
    2660          14 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2661             :                              sl->mb_y, ER_MB_ERROR);
    2662          14 :                 return ret;
    2663             :             }
    2664             : 
    2665     4089403 :             if (++sl->mb_x >= h->mb_width) {
    2666      152495 :                 loop_filter(h, sl, lf_x_start, sl->mb_x);
    2667      152495 :                 sl->mb_x = lf_x_start = 0;
    2668      152495 :                 decode_finish_row(h, sl);
    2669      152495 :                 ++sl->mb_y;
    2670      152495 :                 if (FIELD_OR_MBAFF_PICTURE(h)) {
    2671       32147 :                     ++sl->mb_y;
    2672       32147 :                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
    2673        4978 :                         predict_field_decoding_flag(h, sl);
    2674             :                 }
    2675      152495 :                 if (sl->mb_y >= h->mb_height) {
    2676             :                     ff_tlog(h->avctx, "slice end %d %d\n",
    2677             :                             get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2678             : 
    2679       12330 :                     if (   get_bits_left(&sl->gb) == 0
    2680           0 :                         || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
    2681       24660 :                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2682       12330 :                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
    2683             : 
    2684       12330 :                         goto finish;
    2685             :                     } else {
    2686           0 :                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2687             :                                      sl->mb_x, sl->mb_y, ER_MB_END);
    2688             : 
    2689           0 :                         return AVERROR_INVALIDDATA;
    2690             :                     }
    2691             :                 }
    2692             :             }
    2693             : 
    2694     4077073 :             if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
    2695             :                 ff_tlog(h->avctx, "slice end %d %d\n",
    2696             :                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2697             : 
    2698        3580 :                 if (get_bits_left(&sl->gb) == 0) {
    2699        7158 :                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2700        3579 :                                  sl->mb_x - 1, sl->mb_y, ER_MB_END);
    2701        3579 :                     if (sl->mb_x > lf_x_start)
    2702        2715 :                         loop_filter(h, sl, lf_x_start, sl->mb_x);
    2703             : 
    2704        3579 :                     goto finish;
    2705             :                 } else {
    2706           1 :                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2707             :                                  sl->mb_y, ER_MB_ERROR);
    2708             : 
    2709           1 :                     return AVERROR_INVALIDDATA;
    2710             :                 }
    2711             :             }
    2712             :         }
    2713             :     }
    2714             : 
    2715       31394 : finish:
    2716       31394 :     sl->deblocking_filter = orig_deblock;
    2717       31394 :     return 0;
    2718             : }
    2719             : 
    2720             : /**
    2721             :  * Call decode_slice() for each context.
    2722             :  *
    2723             :  * @param h h264 master context
    2724             :  */
    2725       56849 : int ff_h264_execute_decode_slices(H264Context *h)
    2726             : {
    2727       56849 :     AVCodecContext *const avctx = h->avctx;
    2728             :     H264SliceContext *sl;
    2729       56849 :     int context_count = h->nb_slice_ctx_queued;
    2730       56849 :     int ret = 0;
    2731             :     int i, j;
    2732             : 
    2733       56849 :     h->slice_ctx[0].next_slice_idx = INT_MAX;
    2734             : 
    2735       56849 :     if (h->avctx->hwaccel || context_count < 1)
    2736       25439 :         return 0;
    2737             : 
    2738       31410 :     av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
    2739             : 
    2740       31410 :     if (context_count == 1) {
    2741             : 
    2742       31410 :         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
    2743       31410 :         h->postpone_filter = 0;
    2744             : 
    2745       31410 :         ret = decode_slice(avctx, &h->slice_ctx[0]);
    2746       31410 :         h->mb_y = h->slice_ctx[0].mb_y;
    2747       31410 :         if (ret < 0)
    2748          16 :             goto finish;
    2749             :     } else {
    2750           0 :         av_assert0(context_count > 0);
    2751           0 :         for (i = 0; i < context_count; i++) {
    2752           0 :             int next_slice_idx = h->mb_width * h->mb_height;
    2753             :             int slice_idx;
    2754             : 
    2755           0 :             sl                 = &h->slice_ctx[i];
    2756             :             if (CONFIG_ERROR_RESILIENCE) {
    2757           0 :                 sl->er.error_count = 0;
    2758             :             }
    2759             : 
    2760             :             /* make sure none of those slices overlap */
    2761           0 :             slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
    2762           0 :             for (j = 0; j < context_count; j++) {
    2763           0 :                 H264SliceContext *sl2 = &h->slice_ctx[j];
    2764           0 :                 int        slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
    2765             : 
    2766           0 :                 if (i == j || slice_idx2 < slice_idx)
    2767           0 :                     continue;
    2768           0 :                 next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
    2769             :             }
    2770           0 :             sl->next_slice_idx = next_slice_idx;
    2771             :         }
    2772             : 
    2773           0 :         avctx->execute(avctx, decode_slice, h->slice_ctx,
    2774             :                        NULL, context_count, sizeof(h->slice_ctx[0]));
    2775             : 
    2776             :         /* pull back stuff from slices to master context */
    2777           0 :         sl                   = &h->slice_ctx[context_count - 1];
    2778           0 :         h->mb_y              = sl->mb_y;
    2779             :         if (CONFIG_ERROR_RESILIENCE) {
    2780           0 :             for (i = 1; i < context_count; i++)
    2781           0 :                 h->slice_ctx[0].er.error_count += h->slice_ctx[i].er.error_count;
    2782             :         }
    2783             : 
    2784           0 :         if (h->postpone_filter) {
    2785           0 :             h->postpone_filter = 0;
    2786             : 
    2787           0 :             for (i = 0; i < context_count; i++) {
    2788             :                 int y_end, x_end;
    2789             : 
    2790           0 :                 sl = &h->slice_ctx[i];
    2791           0 :                 y_end = FFMIN(sl->mb_y + 1, h->mb_height);
    2792           0 :                 x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
    2793             : 
    2794           0 :                 for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
    2795           0 :                     sl->mb_y = j;
    2796           0 :                     loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
    2797           0 :                                 j == y_end - 1 ? x_end : h->mb_width);
    2798             :                 }
    2799             :             }
    2800             :         }
    2801             :     }
    2802             : 
    2803           0 : finish:
    2804       31410 :     h->nb_slice_ctx_queued = 0;
    2805       31410 :     return ret;
    2806             : }

Generated by: LCOV version 1.13