LCOV - code coverage report
Current view: top level - libavcodec - h264dec.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 87 88 98.9 %
Date: 2017-12-15 11:05:35 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... encoder/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             : #ifndef AVCODEC_H264DEC_H
      29             : #define AVCODEC_H264DEC_H
      30             : 
      31             : #include "libavutil/buffer.h"
      32             : #include "libavutil/intreadwrite.h"
      33             : #include "libavutil/thread.h"
      34             : 
      35             : #include "cabac.h"
      36             : #include "error_resilience.h"
      37             : #include "h264_parse.h"
      38             : #include "h264_ps.h"
      39             : #include "h264_sei.h"
      40             : #include "h2645_parse.h"
      41             : #include "h264chroma.h"
      42             : #include "h264dsp.h"
      43             : #include "h264pred.h"
      44             : #include "h264qpel.h"
      45             : #include "internal.h"
      46             : #include "mpegutils.h"
      47             : #include "parser.h"
      48             : #include "qpeldsp.h"
      49             : #include "rectangle.h"
      50             : #include "videodsp.h"
      51             : 
      52             : #define H264_MAX_PICTURE_COUNT 36
      53             : 
      54             : #define MAX_MMCO_COUNT         66
      55             : 
      56             : #define MAX_DELAYED_PIC_COUNT  16
      57             : 
      58             : /* Compiling in interlaced support reduces the speed
      59             :  * of progressive decoding by about 2%. */
      60             : #define ALLOW_INTERLACE
      61             : 
      62             : #define FMO 0
      63             : 
      64             : /**
      65             :  * The maximum number of slices supported by the decoder.
      66             :  * must be a power of 2
      67             :  */
      68             : #define MAX_SLICES 32
      69             : 
      70             : #ifdef ALLOW_INTERLACE
      71             : #define MB_MBAFF(h)    (h)->mb_mbaff
      72             : #define MB_FIELD(sl)  (sl)->mb_field_decoding_flag
      73             : #define FRAME_MBAFF(h) (h)->mb_aff_frame
      74             : #define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME)
      75             : #define LEFT_MBS 2
      76             : #define LTOP     0
      77             : #define LBOT     1
      78             : #define LEFT(i)  (i)
      79             : #else
      80             : #define MB_MBAFF(h)      0
      81             : #define MB_FIELD(sl)     0
      82             : #define FRAME_MBAFF(h)   0
      83             : #define FIELD_PICTURE(h) 0
      84             : #undef  IS_INTERLACED
      85             : #define IS_INTERLACED(mb_type) 0
      86             : #define LEFT_MBS 1
      87             : #define LTOP     0
      88             : #define LBOT     0
      89             : #define LEFT(i)  0
      90             : #endif
      91             : #define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
      92             : 
      93             : #ifndef CABAC
      94             : #define CABAC(h) (h)->ps.pps->cabac
      95             : #endif
      96             : 
      97             : #define CHROMA(h)    ((h)->ps.sps->chroma_format_idc)
      98             : #define CHROMA422(h) ((h)->ps.sps->chroma_format_idc == 2)
      99             : #define CHROMA444(h) ((h)->ps.sps->chroma_format_idc == 3)
     100             : 
     101             : #define MB_TYPE_REF0       MB_TYPE_ACPRED // dirty but it fits in 16 bit
     102             : #define MB_TYPE_8x8DCT     0x01000000
     103             : #define IS_REF0(a)         ((a) & MB_TYPE_REF0)
     104             : #define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
     105             : 
     106             : /**
     107             :  * Memory management control operation opcode.
     108             :  */
     109             : typedef enum MMCOOpcode {
     110             :     MMCO_END = 0,
     111             :     MMCO_SHORT2UNUSED,
     112             :     MMCO_LONG2UNUSED,
     113             :     MMCO_SHORT2LONG,
     114             :     MMCO_SET_MAX_LONG,
     115             :     MMCO_RESET,
     116             :     MMCO_LONG,
     117             : } MMCOOpcode;
     118             : 
     119             : /**
     120             :  * Memory management control operation.
     121             :  */
     122             : typedef struct MMCO {
     123             :     MMCOOpcode opcode;
     124             :     int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
     125             :     int long_arg;       ///< index, pic_num, or num long refs depending on opcode
     126             : } MMCO;
     127             : 
     128             : typedef struct H264Picture {
     129             :     AVFrame *f;
     130             :     ThreadFrame tf;
     131             : 
     132             :     AVBufferRef *qscale_table_buf;
     133             :     int8_t *qscale_table;
     134             : 
     135             :     AVBufferRef *motion_val_buf[2];
     136             :     int16_t (*motion_val[2])[2];
     137             : 
     138             :     AVBufferRef *mb_type_buf;
     139             :     uint32_t *mb_type;
     140             : 
     141             :     AVBufferRef *hwaccel_priv_buf;
     142             :     void *hwaccel_picture_private; ///< hardware accelerator private data
     143             : 
     144             :     AVBufferRef *ref_index_buf[2];
     145             :     int8_t *ref_index[2];
     146             : 
     147             :     int field_poc[2];       ///< top/bottom POC
     148             :     int poc;                ///< frame POC
     149             :     int frame_num;          ///< frame_num (raw frame_num from slice header)
     150             :     int mmco_reset;         /**< MMCO_RESET set this 1. Reordering code must
     151             :                                  not mix pictures before and after MMCO_RESET. */
     152             :     int pic_id;             /**< pic_num (short -> no wrap version of pic_num,
     153             :                                  pic_num & max_pic_num; long -> long_pic_num) */
     154             :     int long_ref;           ///< 1->long term reference 0->short term reference
     155             :     int ref_poc[2][2][32];  ///< POCs of the frames/fields used as reference (FIXME need per slice)
     156             :     int ref_count[2][2];    ///< number of entries in ref_poc         (FIXME need per slice)
     157             :     int mbaff;              ///< 1 -> MBAFF frame 0-> not MBAFF
     158             :     int field_picture;      ///< whether or not picture was encoded in separate fields
     159             : 
     160             :     int reference;
     161             :     int recovered;          ///< picture at IDR or recovery point + recovery count
     162             :     int invalid_gap;
     163             :     int sei_recovery_frame_cnt;
     164             : } H264Picture;
     165             : 
     166             : typedef struct H264Ref {
     167             :     uint8_t *data[3];
     168             :     int linesize[3];
     169             : 
     170             :     int reference;
     171             :     int poc;
     172             :     int pic_id;
     173             : 
     174             :     H264Picture *parent;
     175             : } H264Ref;
     176             : 
     177             : typedef struct H264SliceContext {
     178             :     struct H264Context *h264;
     179             :     GetBitContext gb;
     180             :     ERContext er;
     181             : 
     182             :     int slice_num;
     183             :     int slice_type;
     184             :     int slice_type_nos;         ///< S free slice type (SI/SP are remapped to I/P)
     185             :     int slice_type_fixed;
     186             : 
     187             :     int qscale;
     188             :     int chroma_qp[2];   // QPc
     189             :     int qp_thresh;      ///< QP threshold to skip loopfilter
     190             :     int last_qscale_diff;
     191             : 
     192             :     // deblock
     193             :     int deblocking_filter;          ///< disable_deblocking_filter_idc with 1 <-> 0
     194             :     int slice_alpha_c0_offset;
     195             :     int slice_beta_offset;
     196             : 
     197             :     H264PredWeightTable pwt;
     198             : 
     199             :     int prev_mb_skipped;
     200             :     int next_mb_skipped;
     201             : 
     202             :     int chroma_pred_mode;
     203             :     int intra16x16_pred_mode;
     204             : 
     205             :     int8_t intra4x4_pred_mode_cache[5 * 8];
     206             :     int8_t(*intra4x4_pred_mode);
     207             : 
     208             :     int topleft_mb_xy;
     209             :     int top_mb_xy;
     210             :     int topright_mb_xy;
     211             :     int left_mb_xy[LEFT_MBS];
     212             : 
     213             :     int topleft_type;
     214             :     int top_type;
     215             :     int topright_type;
     216             :     int left_type[LEFT_MBS];
     217             : 
     218             :     const uint8_t *left_block;
     219             :     int topleft_partition;
     220             : 
     221             :     unsigned int topleft_samples_available;
     222             :     unsigned int top_samples_available;
     223             :     unsigned int topright_samples_available;
     224             :     unsigned int left_samples_available;
     225             : 
     226             :     ptrdiff_t linesize, uvlinesize;
     227             :     ptrdiff_t mb_linesize;  ///< may be equal to s->linesize or s->linesize * 2, for mbaff
     228             :     ptrdiff_t mb_uvlinesize;
     229             : 
     230             :     int mb_x, mb_y;
     231             :     int mb_xy;
     232             :     int resync_mb_x;
     233             :     int resync_mb_y;
     234             :     unsigned int first_mb_addr;
     235             :     // index of the first MB of the next slice
     236             :     int next_slice_idx;
     237             :     int mb_skip_run;
     238             :     int is_complex;
     239             : 
     240             :     int picture_structure;
     241             :     int mb_field_decoding_flag;
     242             :     int mb_mbaff;               ///< mb_aff_frame && mb_field_decoding_flag
     243             : 
     244             :     int redundant_pic_count;
     245             : 
     246             :     /**
     247             :      * number of neighbors (top and/or left) that used 8x8 dct
     248             :      */
     249             :     int neighbor_transform_size;
     250             : 
     251             :     int direct_spatial_mv_pred;
     252             :     int col_parity;
     253             :     int col_fieldoff;
     254             : 
     255             :     int cbp;
     256             :     int top_cbp;
     257             :     int left_cbp;
     258             : 
     259             :     int dist_scale_factor[32];
     260             :     int dist_scale_factor_field[2][32];
     261             :     int map_col_to_list0[2][16 + 32];
     262             :     int map_col_to_list0_field[2][2][16 + 32];
     263             : 
     264             :     /**
     265             :      * num_ref_idx_l0/1_active_minus1 + 1
     266             :      */
     267             :     unsigned int ref_count[2];          ///< counts frames or fields, depending on current mb mode
     268             :     unsigned int list_count;
     269             :     H264Ref ref_list[2][48];        /**< 0..15: frame refs, 16..47: mbaff field refs.
     270             :                                          *   Reordered version of default_ref_list
     271             :                                          *   according to picture reordering in slice header */
     272             :     struct {
     273             :         uint8_t op;
     274             :         uint32_t val;
     275             :     } ref_modifications[2][32];
     276             :     int nb_ref_modifications[2];
     277             : 
     278             :     unsigned int pps_id;
     279             : 
     280             :     const uint8_t *intra_pcm_ptr;
     281             :     int16_t *dc_val_base;
     282             : 
     283             :     uint8_t *bipred_scratchpad;
     284             :     uint8_t *edge_emu_buffer;
     285             :     uint8_t (*top_borders[2])[(16 * 3) * 2];
     286             :     int bipred_scratchpad_allocated;
     287             :     int edge_emu_buffer_allocated;
     288             :     int top_borders_allocated[2];
     289             : 
     290             :     /**
     291             :      * non zero coeff count cache.
     292             :      * is 64 if not available.
     293             :      */
     294             :     DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
     295             : 
     296             :     /**
     297             :      * Motion vector cache.
     298             :      */
     299             :     DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
     300             :     DECLARE_ALIGNED(8,  int8_t, ref_cache)[2][5 * 8];
     301             :     DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
     302             :     uint8_t direct_cache[5 * 8];
     303             : 
     304             :     DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
     305             : 
     306             :     ///< as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
     307             :     DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
     308             :     DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
     309             :     ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either
     310             :     ///< check that i is not too large or ensure that there is some unused stuff after mb
     311             :     int16_t mb_padding[256 * 2];
     312             : 
     313             :     uint8_t (*mvd_table[2])[2];
     314             : 
     315             :     /**
     316             :      * Cabac
     317             :      */
     318             :     CABACContext cabac;
     319             :     uint8_t cabac_state[1024];
     320             :     int cabac_init_idc;
     321             : 
     322             :     MMCO mmco[MAX_MMCO_COUNT];
     323             :     int  nb_mmco;
     324             :     int explicit_ref_marking;
     325             : 
     326             :     int frame_num;
     327             :     int poc_lsb;
     328             :     int delta_poc_bottom;
     329             :     int delta_poc[2];
     330             :     int curr_pic_num;
     331             :     int max_pic_num;
     332             : } H264SliceContext;
     333             : 
     334             : /**
     335             :  * H264Context
     336             :  */
     337             : typedef struct H264Context {
     338             :     const AVClass *class;
     339             :     AVCodecContext *avctx;
     340             :     VideoDSPContext vdsp;
     341             :     H264DSPContext h264dsp;
     342             :     H264ChromaContext h264chroma;
     343             :     H264QpelContext h264qpel;
     344             : 
     345             :     H264Picture DPB[H264_MAX_PICTURE_COUNT];
     346             :     H264Picture *cur_pic_ptr;
     347             :     H264Picture cur_pic;
     348             :     H264Picture last_pic_for_ec;
     349             : 
     350             :     H264SliceContext *slice_ctx;
     351             :     int            nb_slice_ctx;
     352             :     int            nb_slice_ctx_queued;
     353             : 
     354             :     H2645Packet pkt;
     355             : 
     356             :     int pixel_shift;    ///< 0 for 8-bit H.264, 1 for high-bit-depth H.264
     357             : 
     358             :     /* coded dimensions -- 16 * mb w/h */
     359             :     int width, height;
     360             :     int chroma_x_shift, chroma_y_shift;
     361             : 
     362             :     int droppable;
     363             :     int coded_picture_number;
     364             : 
     365             :     int context_initialized;
     366             :     int flags;
     367             :     int workaround_bugs;
     368             :     int x264_build;
     369             :     /* Set when slice threading is used and at least one slice uses deblocking
     370             :      * mode 1 (i.e. across slice boundaries). Then we disable the loop filter
     371             :      * during normal MB decoding and execute it serially at the end.
     372             :      */
     373             :     int postpone_filter;
     374             : 
     375             :     /*
     376             :      * Set to 1 when the current picture is IDR, 0 otherwise.
     377             :      */
     378             :     int picture_idr;
     379             : 
     380             :     int crop_left;
     381             :     int crop_right;
     382             :     int crop_top;
     383             :     int crop_bottom;
     384             : 
     385             :     int8_t(*intra4x4_pred_mode);
     386             :     H264PredContext hpc;
     387             : 
     388             :     uint8_t (*non_zero_count)[48];
     389             : 
     390             : #define LIST_NOT_USED -1 // FIXME rename?
     391             : #define PART_NOT_AVAILABLE -2
     392             : 
     393             :     /**
     394             :      * block_offset[ 0..23] for frame macroblocks
     395             :      * block_offset[24..47] for field macroblocks
     396             :      */
     397             :     int block_offset[2 * (16 * 3)];
     398             : 
     399             :     uint32_t *mb2b_xy;  // FIXME are these 4 a good idea?
     400             :     uint32_t *mb2br_xy;
     401             :     int b_stride;       // FIXME use s->b4_stride
     402             : 
     403             :     uint16_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1
     404             : 
     405             :     // interlacing specific flags
     406             :     int mb_aff_frame;
     407             :     int picture_structure;
     408             :     int first_field;
     409             : 
     410             :     uint8_t *list_counts;               ///< Array of list_count per MB specifying the slice type
     411             : 
     412             :     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
     413             :     uint16_t *cbp_table;
     414             : 
     415             :     /* chroma_pred_mode for i4x4 or i16x16, else 0 */
     416             :     uint8_t *chroma_pred_mode_table;
     417             :     uint8_t (*mvd_table[2])[2];
     418             :     uint8_t *direct_table;
     419             : 
     420             :     uint8_t scan_padding[16];
     421             :     uint8_t zigzag_scan[16];
     422             :     uint8_t zigzag_scan8x8[64];
     423             :     uint8_t zigzag_scan8x8_cavlc[64];
     424             :     uint8_t field_scan[16];
     425             :     uint8_t field_scan8x8[64];
     426             :     uint8_t field_scan8x8_cavlc[64];
     427             :     uint8_t zigzag_scan_q0[16];
     428             :     uint8_t zigzag_scan8x8_q0[64];
     429             :     uint8_t zigzag_scan8x8_cavlc_q0[64];
     430             :     uint8_t field_scan_q0[16];
     431             :     uint8_t field_scan8x8_q0[64];
     432             :     uint8_t field_scan8x8_cavlc_q0[64];
     433             : 
     434             :     int mb_y;
     435             :     int mb_height, mb_width;
     436             :     int mb_stride;
     437             :     int mb_num;
     438             : 
     439             :     // =============================================================
     440             :     // Things below are not used in the MB or more inner code
     441             : 
     442             :     int nal_ref_idc;
     443             :     int nal_unit_type;
     444             : 
     445             :     int has_slice;          ///< slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved outside h264_decode_frame()
     446             : 
     447             :     /**
     448             :      * Used to parse AVC variant of H.264
     449             :      */
     450             :     int is_avc;           ///< this flag is != 0 if codec is avc1
     451             :     int nal_length_size;  ///< Number of bytes used for nal length (1, 2 or 4)
     452             : 
     453             :     int bit_depth_luma;         ///< luma bit depth from sps to detect changes
     454             :     int chroma_format_idc;      ///< chroma format from sps to detect changes
     455             : 
     456             :     H264ParamSets ps;
     457             : 
     458             :     uint16_t *slice_table_base;
     459             : 
     460             :     H264POCContext poc;
     461             : 
     462             :     H264Ref default_ref[2];
     463             :     H264Picture *short_ref[32];
     464             :     H264Picture *long_ref[32];
     465             :     H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
     466             :     int last_pocs[MAX_DELAYED_PIC_COUNT];
     467             :     H264Picture *next_output_pic;
     468             :     int next_outputed_poc;
     469             : 
     470             :     /**
     471             :      * memory management control operations buffer.
     472             :      */
     473             :     MMCO mmco[MAX_MMCO_COUNT];
     474             :     int  nb_mmco;
     475             :     int mmco_reset;
     476             :     int explicit_ref_marking;
     477             : 
     478             :     int long_ref_count;     ///< number of actual long term references
     479             :     int short_ref_count;    ///< number of actual short term references
     480             : 
     481             :     /**
     482             :      * @name Members for slice based multithreading
     483             :      * @{
     484             :      */
     485             :     /**
     486             :      * current slice number, used to initialize slice_num of each thread/context
     487             :      */
     488             :     int current_slice;
     489             : 
     490             :     /** @} */
     491             : 
     492             :     /**
     493             :      * Complement sei_pic_struct
     494             :      * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
     495             :      * However, soft telecined frames may have these values.
     496             :      * This is used in an attempt to flag soft telecine progressive.
     497             :      */
     498             :     int prev_interlaced_frame;
     499             : 
     500             :     /**
     501             :      * Are the SEI recovery points looking valid.
     502             :      */
     503             :     int valid_recovery_point;
     504             : 
     505             :     /**
     506             :      * recovery_frame is the frame_num at which the next frame should
     507             :      * be fully constructed.
     508             :      *
     509             :      * Set to -1 when not expecting a recovery point.
     510             :      */
     511             :     int recovery_frame;
     512             : 
     513             : /**
     514             :  * We have seen an IDR, so all the following frames in coded order are correctly
     515             :  * decodable.
     516             :  */
     517             : #define FRAME_RECOVERED_IDR  (1 << 0)
     518             : /**
     519             :  * Sufficient number of frames have been decoded since a SEI recovery point,
     520             :  * so all the following frames in presentation order are correct.
     521             :  */
     522             : #define FRAME_RECOVERED_SEI  (1 << 1)
     523             : 
     524             :     int frame_recovered;    ///< Initial frame has been completely recovered
     525             : 
     526             :     int has_recovery_point;
     527             : 
     528             :     int missing_fields;
     529             : 
     530             :     /* for frame threading, this is set to 1
     531             :      * after finish_setup() has been called, so we cannot modify
     532             :      * some context properties (which are supposed to stay constant between
     533             :      * slices) anymore */
     534             :     int setup_finished;
     535             : 
     536             :     int cur_chroma_format_idc;
     537             :     int cur_bit_depth_luma;
     538             :     int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
     539             : 
     540             :     /* original AVCodecContext dimensions, used to handle container
     541             :      * cropping */
     542             :     int width_from_caller;
     543             :     int height_from_caller;
     544             : 
     545             :     int enable_er;
     546             : 
     547             :     H264SEIContext sei;
     548             : 
     549             :     AVBufferPool *qscale_table_pool;
     550             :     AVBufferPool *mb_type_pool;
     551             :     AVBufferPool *motion_val_pool;
     552             :     AVBufferPool *ref_index_pool;
     553             :     int ref2frm[MAX_SLICES][2][64];     ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
     554             : } H264Context;
     555             : 
     556             : extern const uint16_t ff_h264_mb_sizes[4];
     557             : 
     558             : /**
     559             :  * Reconstruct bitstream slice_type.
     560             :  */
     561             : int ff_h264_get_slice_type(const H264SliceContext *sl);
     562             : 
     563             : /**
     564             :  * Allocate tables.
     565             :  * needs width/height
     566             :  */
     567             : int ff_h264_alloc_tables(H264Context *h);
     568             : 
     569             : int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx);
     570             : int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl);
     571             : void ff_h264_remove_all_refs(H264Context *h);
     572             : 
     573             : /**
     574             :  * Execute the reference picture marking (memory management control operations).
     575             :  */
     576             : int ff_h264_execute_ref_pic_marking(H264Context *h);
     577             : 
     578             : int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
     579             :                                    const H2645NAL *nal, void *logctx);
     580             : 
     581             : void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl);
     582             : void ff_h264_decode_init_vlc(void);
     583             : 
     584             : /**
     585             :  * Decode a macroblock
     586             :  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
     587             :  */
     588             : int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl);
     589             : 
     590             : /**
     591             :  * Decode a CABAC coded macroblock
     592             :  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
     593             :  */
     594             : int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl);
     595             : 
     596             : void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl);
     597             : 
     598             : void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl);
     599             : void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl);
     600             : void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl,
     601             :                                 int *mb_type);
     602             : 
     603             : void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
     604             :                             uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
     605             :                             unsigned int linesize, unsigned int uvlinesize);
     606             : void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
     607             :                        uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
     608             :                        unsigned int linesize, unsigned int uvlinesize);
     609             : 
     610             : /*
     611             :  * o-o o-o
     612             :  *  / / /
     613             :  * o-o o-o
     614             :  *  ,---'
     615             :  * o-o o-o
     616             :  *  / / /
     617             :  * o-o o-o
     618             :  */
     619             : 
     620             : /* Scan8 organization:
     621             :  *    0 1 2 3 4 5 6 7
     622             :  * 0  DY    y y y y y
     623             :  * 1        y Y Y Y Y
     624             :  * 2        y Y Y Y Y
     625             :  * 3        y Y Y Y Y
     626             :  * 4        y Y Y Y Y
     627             :  * 5  DU    u u u u u
     628             :  * 6        u U U U U
     629             :  * 7        u U U U U
     630             :  * 8        u U U U U
     631             :  * 9        u U U U U
     632             :  * 10 DV    v v v v v
     633             :  * 11       v V V V V
     634             :  * 12       v V V V V
     635             :  * 13       v V V V V
     636             :  * 14       v V V V V
     637             :  * DY/DU/DV are for luma/chroma DC.
     638             :  */
     639             : 
     640             : #define LUMA_DC_BLOCK_INDEX   48
     641             : #define CHROMA_DC_BLOCK_INDEX 49
     642             : 
     643             : // This table must be here because scan8[constant] must be known at compiletime
     644             : static const uint8_t scan8[16 * 3 + 3] = {
     645             :     4 +  1 * 8, 5 +  1 * 8, 4 +  2 * 8, 5 +  2 * 8,
     646             :     6 +  1 * 8, 7 +  1 * 8, 6 +  2 * 8, 7 +  2 * 8,
     647             :     4 +  3 * 8, 5 +  3 * 8, 4 +  4 * 8, 5 +  4 * 8,
     648             :     6 +  3 * 8, 7 +  3 * 8, 6 +  4 * 8, 7 +  4 * 8,
     649             :     4 +  6 * 8, 5 +  6 * 8, 4 +  7 * 8, 5 +  7 * 8,
     650             :     6 +  6 * 8, 7 +  6 * 8, 6 +  7 * 8, 7 +  7 * 8,
     651             :     4 +  8 * 8, 5 +  8 * 8, 4 +  9 * 8, 5 +  9 * 8,
     652             :     6 +  8 * 8, 7 +  8 * 8, 6 +  9 * 8, 7 +  9 * 8,
     653             :     4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
     654             :     6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
     655             :     4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
     656             :     6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
     657             :     0 +  0 * 8, 0 +  5 * 8, 0 + 10 * 8
     658             : };
     659             : 
     660    29675775 : static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
     661             : {
     662             : #if HAVE_BIGENDIAN
     663             :     return (b & 0xFFFF) + (a << 16);
     664             : #else
     665    29675775 :     return (a & 0xFFFF) + (b << 16);
     666             : #endif
     667             : }
     668             : 
     669     3474686 : static av_always_inline uint16_t pack8to16(unsigned a, unsigned b)
     670             : {
     671             : #if HAVE_BIGENDIAN
     672             :     return (b & 0xFF) + (a << 8);
     673             : #else
     674     3474686 :     return (a & 0xFF) + (b << 8);
     675             : #endif
     676             : }
     677             : 
     678             : /**
     679             :  * Get the chroma qp.
     680             :  */
     681    56562762 : static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
     682             : {
     683    56562762 :     return pps->chroma_qp_table[t][qscale];
     684             : }
     685             : 
     686             : /**
     687             :  * Get the predicted intra4x4 prediction mode.
     688             :  */
     689    28476408 : static av_always_inline int pred_intra_mode(const H264Context *h,
     690             :                                             H264SliceContext *sl, int n)
     691             : {
     692    28476408 :     const int index8 = scan8[n];
     693    28476408 :     const int left   = sl->intra4x4_pred_mode_cache[index8 - 1];
     694    28476408 :     const int top    = sl->intra4x4_pred_mode_cache[index8 - 8];
     695    28476408 :     const int min    = FFMIN(left, top);
     696             : 
     697             :     ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min);
     698             : 
     699    28476408 :     if (min < 0)
     700      799628 :         return DC_PRED;
     701             :     else
     702    27676780 :         return min;
     703             : }
     704             : 
     705     2857332 : static av_always_inline void write_back_intra_pred_mode(const H264Context *h,
     706             :                                                         H264SliceContext *sl)
     707             : {
     708     2857332 :     int8_t *i4x4       = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
     709     2857332 :     int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
     710             : 
     711     2857332 :     AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
     712     2857332 :     i4x4[4] = i4x4_cache[7 + 8 * 3];
     713     2857332 :     i4x4[5] = i4x4_cache[7 + 8 * 2];
     714     2857332 :     i4x4[6] = i4x4_cache[7 + 8 * 1];
     715     2857332 : }
     716             : 
     717     9603524 : static av_always_inline void write_back_non_zero_count(const H264Context *h,
     718             :                                                        H264SliceContext *sl)
     719             : {
     720     9603524 :     const int mb_xy    = sl->mb_xy;
     721     9603524 :     uint8_t *nnz       = h->non_zero_count[mb_xy];
     722     9603524 :     uint8_t *nnz_cache = sl->non_zero_count_cache;
     723             : 
     724     9603524 :     AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
     725     9603524 :     AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
     726     9603524 :     AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
     727     9603524 :     AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
     728     9603524 :     AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
     729     9603524 :     AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
     730     9603524 :     AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
     731     9603524 :     AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
     732             : 
     733     9603524 :     if (!h->chroma_y_shift) {
     734      914377 :         AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
     735      914377 :         AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
     736      914377 :         AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
     737      914377 :         AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
     738             :     }
     739     9603524 : }
     740             : 
     741    11581735 : static av_always_inline void write_back_motion_list(const H264Context *h,
     742             :                                                     H264SliceContext *sl,
     743             :                                                     int b_stride,
     744             :                                                     int b_xy, int b8_xy,
     745             :                                                     int mb_type, int list)
     746             : {
     747    11581735 :     int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy];
     748    11581735 :     int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]];
     749    11581735 :     AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
     750    11581735 :     AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
     751    11581735 :     AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
     752    11581735 :     AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
     753           0 :     if (CABAC(h)) {
     754    16019686 :         uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy
     755     8009843 :                                                         : h->mb2br_xy[sl->mb_xy]];
     756     8009843 :         uint8_t(*mvd_src)[2]  = &sl->mvd_cache[list][scan8[0]];
     757     8009843 :         if (IS_SKIP(mb_type)) {
     758     3095616 :             AV_ZERO128(mvd_dst);
     759             :         } else {
     760     4914227 :             AV_COPY64(mvd_dst, mvd_src + 8 * 3);
     761     4914227 :             AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
     762     4914227 :             AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
     763     4914227 :             AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
     764             :         }
     765             :     }
     766             : 
     767             :     {
     768    11581735 :         int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy];
     769    11581735 :         int8_t *ref_cache = sl->ref_cache[list];
     770    11581735 :         ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
     771    11581735 :         ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
     772    11581735 :         ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
     773    11581735 :         ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
     774             :     }
     775    11581735 : }
     776             : 
     777     8718414 : static av_always_inline void write_back_motion(const H264Context *h,
     778             :                                                H264SliceContext *sl,
     779             :                                                int mb_type)
     780             : {
     781     8718414 :     const int b_stride      = h->b_stride;
     782     8718414 :     const int b_xy  = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy
     783     8718414 :     const int b8_xy = 4 * sl->mb_xy;
     784             : 
     785     8718414 :     if (USES_LIST(mb_type, 0)) {
     786     8043631 :         write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0);
     787             :     } else {
     788      674783 :         fill_rectangle(&h->cur_pic.ref_index[0][b8_xy],
     789             :                        2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
     790             :     }
     791     8718414 :     if (USES_LIST(mb_type, 1))
     792     3538104 :         write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
     793             : 
     794     5759170 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
     795     3438617 :         if (IS_8X8(mb_type)) {
     796      408004 :             uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy];
     797      408004 :             direct_table[1] = sl->sub_mb_type[1] >> 1;
     798      408004 :             direct_table[2] = sl->sub_mb_type[2] >> 1;
     799      408004 :             direct_table[3] = sl->sub_mb_type[3] >> 1;
     800             :         }
     801             :     }
     802     8718414 : }
     803             : 
     804      233484 : static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
     805             : {
     806      233484 :     if (h->ps.sps->direct_8x8_inference_flag)
     807      228607 :         return !(AV_RN64A(sl->sub_mb_type) &
     808             :                  ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) *
     809             :                   0x0001000100010001ULL));
     810             :     else
     811        4877 :         return !(AV_RN64A(sl->sub_mb_type) &
     812             :                  ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2) *
     813             :                   0x0001000100010001ULL));
     814             : }
     815             : 
     816       34570 : static inline int find_start_code(const uint8_t *buf, int buf_size,
     817             :                            int buf_index, int next_avc)
     818             : {
     819       34570 :     uint32_t state = -1;
     820             : 
     821       34570 :     buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1;
     822             : 
     823       34570 :     return FFMIN(buf_index, buf_size);
     824             : }
     825             : 
     826             : int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
     827             : 
     828             : int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src);
     829             : void ff_h264_unref_picture(H264Context *h, H264Picture *pic);
     830             : 
     831             : int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl);
     832             : 
     833             : void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height);
     834             : 
     835             : int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
     836             :                                 const H2645NAL *nal);
     837             : /**
     838             :  * Submit a slice for decoding.
     839             :  *
     840             :  * Parse the slice header, starting a new field/frame if necessary. If any
     841             :  * slices are queued for the previous field, they are decoded.
     842             :  */
     843             : int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal);
     844             : int ff_h264_execute_decode_slices(H264Context *h);
     845             : int ff_h264_update_thread_context(AVCodecContext *dst,
     846             :                                   const AVCodecContext *src);
     847             : 
     848             : void ff_h264_flush_change(H264Context *h);
     849             : 
     850             : void ff_h264_free_tables(H264Context *h);
     851             : 
     852             : void ff_h264_set_erpic(ERPicture *dst, H264Picture *src);
     853             : 
     854             : #endif /* AVCODEC_H264DEC_H */

Generated by: LCOV version 1.13