LCOV - code coverage report
Current view: top level - libavcodec - cavs.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 12 12 100.0 %
Date: 2017-12-13 10:57:33 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Chinese AVS video (AVS1-P2, JiZhun profile) decoder.
       3             :  * Copyright (c) 2006  Stefan Gehrer <stefan.gehrer@gmx.de>
       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             : #ifndef AVCODEC_CAVS_H
      23             : #define AVCODEC_CAVS_H
      24             : 
      25             : #include "cavsdsp.h"
      26             : #include "blockdsp.h"
      27             : #include "h264chroma.h"
      28             : #include "idctdsp.h"
      29             : #include "get_bits.h"
      30             : #include "videodsp.h"
      31             : 
      32             : #define SLICE_MAX_START_CODE    0x000001af
      33             : #define EXT_START_CODE          0x000001b5
      34             : #define USER_START_CODE         0x000001b2
      35             : #define CAVS_START_CODE         0x000001b0
      36             : #define PIC_I_START_CODE        0x000001b3
      37             : #define PIC_PB_START_CODE       0x000001b6
      38             : 
      39             : #define A_AVAIL                          1
      40             : #define B_AVAIL                          2
      41             : #define C_AVAIL                          4
      42             : #define D_AVAIL                          8
      43             : #define NOT_AVAIL                       -1
      44             : #define REF_INTRA                       -2
      45             : #define REF_DIR                         -3
      46             : 
      47             : #define ESCAPE_CODE                     59
      48             : 
      49             : #define FWD0                          0x01
      50             : #define FWD1                          0x02
      51             : #define BWD0                          0x04
      52             : #define BWD1                          0x08
      53             : #define SYM0                          0x10
      54             : #define SYM1                          0x20
      55             : #define SPLITH                        0x40
      56             : #define SPLITV                        0x80
      57             : 
      58             : #define MV_BWD_OFFS                     12
      59             : #define MV_STRIDE                        4
      60             : 
      61             : enum cavs_mb {
      62             :   I_8X8 = 0,
      63             :   P_SKIP,
      64             :   P_16X16,
      65             :   P_16X8,
      66             :   P_8X16,
      67             :   P_8X8,
      68             :   B_SKIP,
      69             :   B_DIRECT,
      70             :   B_FWD_16X16,
      71             :   B_BWD_16X16,
      72             :   B_SYM_16X16,
      73             :   B_8X8 = 29
      74             : };
      75             : 
      76             : enum cavs_sub_mb {
      77             :   B_SUB_DIRECT,
      78             :   B_SUB_FWD,
      79             :   B_SUB_BWD,
      80             :   B_SUB_SYM
      81             : };
      82             : 
      83             : enum cavs_intra_luma {
      84             :   INTRA_L_VERT,
      85             :   INTRA_L_HORIZ,
      86             :   INTRA_L_LP,
      87             :   INTRA_L_DOWN_LEFT,
      88             :   INTRA_L_DOWN_RIGHT,
      89             :   INTRA_L_LP_LEFT,
      90             :   INTRA_L_LP_TOP,
      91             :   INTRA_L_DC_128
      92             : };
      93             : 
      94             : enum cavs_intra_chroma {
      95             :   INTRA_C_LP,
      96             :   INTRA_C_HORIZ,
      97             :   INTRA_C_VERT,
      98             :   INTRA_C_PLANE,
      99             :   INTRA_C_LP_LEFT,
     100             :   INTRA_C_LP_TOP,
     101             :   INTRA_C_DC_128,
     102             : };
     103             : 
     104             : enum cavs_mv_pred {
     105             :   MV_PRED_MEDIAN,
     106             :   MV_PRED_LEFT,
     107             :   MV_PRED_TOP,
     108             :   MV_PRED_TOPRIGHT,
     109             :   MV_PRED_PSKIP,
     110             :   MV_PRED_BSKIP
     111             : };
     112             : 
     113             : enum cavs_block {
     114             :   BLK_16X16,
     115             :   BLK_16X8,
     116             :   BLK_8X16,
     117             :   BLK_8X8
     118             : };
     119             : 
     120             : enum cavs_mv_loc {
     121             :   MV_FWD_D3 = 0,
     122             :   MV_FWD_B2,
     123             :   MV_FWD_B3,
     124             :   MV_FWD_C2,
     125             :   MV_FWD_A1,
     126             :   MV_FWD_X0,
     127             :   MV_FWD_X1,
     128             :   MV_FWD_A3 = 8,
     129             :   MV_FWD_X2,
     130             :   MV_FWD_X3,
     131             :   MV_BWD_D3 = MV_BWD_OFFS,
     132             :   MV_BWD_B2,
     133             :   MV_BWD_B3,
     134             :   MV_BWD_C2,
     135             :   MV_BWD_A1,
     136             :   MV_BWD_X0,
     137             :   MV_BWD_X1,
     138             :   MV_BWD_A3 = MV_BWD_OFFS+8,
     139             :   MV_BWD_X2,
     140             :   MV_BWD_X3
     141             : };
     142             : 
     143             : DECLARE_ALIGNED(8, typedef, struct) {
     144             :     int16_t x;
     145             :     int16_t y;
     146             :     int16_t dist;
     147             :     int16_t ref;
     148             : } cavs_vector;
     149             : 
     150             : struct dec_2dvlc {
     151             :   int8_t rltab[59][3];
     152             :   int8_t level_add[27];
     153             :   int8_t golomb_order;
     154             :   int inc_limit;
     155             :   int8_t max_run;
     156             : };
     157             : 
     158             : typedef struct AVSFrame {
     159             :     AVFrame *f;
     160             :     int poc;
     161             : } AVSFrame;
     162             : 
     163             : typedef struct AVSContext {
     164             :     AVCodecContext *avctx;
     165             :     BlockDSPContext bdsp;
     166             :     H264ChromaContext h264chroma;
     167             :     IDCTDSPContext idsp;
     168             :     VideoDSPContext vdsp;
     169             :     CAVSDSPContext  cdsp;
     170             :     GetBitContext gb;
     171             :     AVSFrame cur;     ///< currently decoded frame
     172             :     AVSFrame DPB[2];  ///< reference frames
     173             :     int dist[2];     ///< temporal distances from current frame to ref frames
     174             :     int low_delay;
     175             :     int profile, level;
     176             :     int aspect_ratio;
     177             :     int mb_width, mb_height;
     178             :     int width, height;
     179             :     int stream_revision; ///<0 for samples from 2006, 1 for rm52j encoder
     180             :     int progressive;
     181             :     int pic_structure;
     182             :     int skip_mode_flag; ///< select between skip_count or one skip_flag per MB
     183             :     int loop_filter_disable;
     184             :     int alpha_offset, beta_offset;
     185             :     int ref_flag;
     186             :     int mbx, mby, mbidx; ///< macroblock coordinates
     187             :     int flags;         ///< availability flags of neighbouring macroblocks
     188             :     int stc;           ///< last start code
     189             :     uint8_t *cy, *cu, *cv; ///< current MB sample pointers
     190             :     int left_qp;
     191             :     uint8_t *top_qp;
     192             : 
     193             :     /** mv motion vector cache
     194             :        0:    D3  B2  B3  C2
     195             :        4:    A1  X0  X1   -
     196             :        8:    A3  X2  X3   -
     197             : 
     198             :        X are the vectors in the current macroblock (5,6,9,10)
     199             :        A is the macroblock to the left (4,8)
     200             :        B is the macroblock to the top (1,2)
     201             :        C is the macroblock to the top-right (3)
     202             :        D is the macroblock to the top-left (0)
     203             : 
     204             :        the same is repeated for backward motion vectors */
     205             :     cavs_vector mv[2*4*3];
     206             :     cavs_vector *top_mv[2];
     207             :     cavs_vector *col_mv;
     208             : 
     209             :     /** luma pred mode cache
     210             :        0:    --  B2  B3
     211             :        3:    A1  X0  X1
     212             :        6:    A3  X2  X3   */
     213             :     int pred_mode_Y[3*3];
     214             :     int *top_pred_Y;
     215             :     ptrdiff_t l_stride, c_stride;
     216             :     int luma_scan[4];
     217             :     int qp;
     218             :     int qp_fixed;
     219             :     int pic_qp_fixed;
     220             :     int cbp;
     221             :     ScanTable scantable;
     222             : 
     223             :     /** intra prediction is done with un-deblocked samples
     224             :      they are saved here before deblocking the MB  */
     225             :     uint8_t *top_border_y, *top_border_u, *top_border_v;
     226             :     uint8_t left_border_y[26], left_border_u[10], left_border_v[10];
     227             :     uint8_t intern_border_y[26];
     228             :     uint8_t topleft_border_y, topleft_border_u, topleft_border_v;
     229             : 
     230             :     void (*intra_pred_l[8])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride);
     231             :     void (*intra_pred_c[7])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride);
     232             :     uint8_t *col_type_base;
     233             : 
     234             :     /* scaling factors for MV prediction */
     235             :     int sym_factor;    ///< for scaling in symmetrical B block
     236             :     int direct_den[2]; ///< for scaling in direct B block
     237             :     int scale_den[2];  ///< for scaling neighbouring MVs
     238             : 
     239             :     uint8_t *edge_emu_buffer;
     240             : 
     241             :     int got_keyframe;
     242             :     int16_t *block;
     243             : } AVSContext;
     244             : 
     245             : extern const uint8_t     ff_cavs_chroma_qp[64];
     246             : extern const uint8_t     ff_cavs_partition_flags[30];
     247             : extern const cavs_vector ff_cavs_intra_mv;
     248             : extern const cavs_vector ff_cavs_dir_mv;
     249             : 
     250      698163 : static inline void set_mvs(cavs_vector *mv, enum cavs_block size) {
     251      698163 :     switch(size) {
     252      548747 :     case BLK_16X16:
     253      548747 :         mv[MV_STRIDE  ] = mv[0];
     254      548747 :         mv[MV_STRIDE+1] = mv[0];
     255      575789 :     case BLK_16X8:
     256      575789 :         mv[1] = mv[0];
     257      575789 :         break;
     258       23840 :     case BLK_8X16:
     259       23840 :         mv[MV_STRIDE] = mv[0];
     260       23840 :         break;
     261             :     }
     262      698163 : }
     263             : 
     264             : void ff_cavs_filter(AVSContext *h, enum cavs_mb mb_type);
     265             : void ff_cavs_load_intra_pred_luma(AVSContext *h, uint8_t *top, uint8_t **left,
     266             :                                   int block);
     267             : void ff_cavs_load_intra_pred_chroma(AVSContext *h);
     268             : void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv);
     269             : void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type);
     270             : void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
     271             :                 enum cavs_mv_pred mode, enum cavs_block size, int ref);
     272             : void ff_cavs_init_mb(AVSContext *h);
     273             : int  ff_cavs_next_mb(AVSContext *h);
     274             : int ff_cavs_init_pic(AVSContext *h);
     275             : int ff_cavs_init_top_lines(AVSContext *h);
     276             : int ff_cavs_init(AVCodecContext *avctx);
     277             : int ff_cavs_end (AVCodecContext *avctx);
     278             : 
     279             : #endif /* AVCODEC_CAVS_H */

Generated by: LCOV version 1.13