LCOV - code coverage report
Current view: directory - media/libvpx/vp8/common - blockd.h (source / functions) Found Hit Coverage
Test: app.info Lines: 7 0 0.0 %
Date: 2012-06-02 Functions: 1 0 0.0 %

       1                 : /*
       2                 :  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
       3                 :  *
       4                 :  *  Use of this source code is governed by a BSD-style license
       5                 :  *  that can be found in the LICENSE file in the root of the source
       6                 :  *  tree. An additional intellectual property rights grant can be found
       7                 :  *  in the file PATENTS.  All contributing project authors may
       8                 :  *  be found in the AUTHORS file in the root of the source tree.
       9                 :  */
      10                 : 
      11                 : 
      12                 : #ifndef __INC_BLOCKD_H
      13                 : #define __INC_BLOCKD_H
      14                 : 
      15                 : void vpx_log(const char *format, ...);
      16                 : 
      17                 : #include "vpx_ports/config.h"
      18                 : #include "vpx_scale/yv12config.h"
      19                 : #include "mv.h"
      20                 : #include "treecoder.h"
      21                 : #include "subpixel.h"
      22                 : #include "vpx_ports/mem.h"
      23                 : 
      24                 : #define TRUE    1
      25                 : #define FALSE   0
      26                 : 
      27                 : /*#define DCPRED 1*/
      28                 : #define DCPREDSIMTHRESH 0
      29                 : #define DCPREDCNTTHRESH 3
      30                 : 
      31                 : #define MB_FEATURE_TREE_PROBS   3
      32                 : #define MAX_MB_SEGMENTS         4
      33                 : 
      34                 : #define MAX_REF_LF_DELTAS       4
      35                 : #define MAX_MODE_LF_DELTAS      4
      36                 : 
      37                 : /* Segment Feature Masks */
      38                 : #define SEGMENT_DELTADATA   0
      39                 : #define SEGMENT_ABSDATA     1
      40                 : 
      41                 : typedef struct
      42                 : {
      43                 :     int r, c;
      44                 : } POS;
      45                 : 
      46                 : #define PLANE_TYPE_Y_NO_DC    0
      47                 : #define PLANE_TYPE_Y2         1
      48                 : #define PLANE_TYPE_UV         2
      49                 : #define PLANE_TYPE_Y_WITH_DC  3
      50                 : 
      51                 : 
      52                 : typedef char ENTROPY_CONTEXT;
      53                 : typedef struct
      54                 : {
      55                 :     ENTROPY_CONTEXT y1[4];
      56                 :     ENTROPY_CONTEXT u[2];
      57                 :     ENTROPY_CONTEXT v[2];
      58                 :     ENTROPY_CONTEXT y2;
      59                 : } ENTROPY_CONTEXT_PLANES;
      60                 : 
      61                 : extern const unsigned char vp8_block2left[25];
      62                 : extern const unsigned char vp8_block2above[25];
      63                 : 
      64                 : #define VP8_COMBINEENTROPYCONTEXTS( Dest, A, B) \
      65                 :     Dest = ((A)!=0) + ((B)!=0);
      66                 : 
      67                 : 
      68                 : typedef enum
      69                 : {
      70                 :     KEY_FRAME = 0,
      71                 :     INTER_FRAME = 1
      72                 : } FRAME_TYPE;
      73                 : 
      74                 : typedef enum
      75                 : {
      76                 :     DC_PRED,            /* average of above and left pixels */
      77                 :     V_PRED,             /* vertical prediction */
      78                 :     H_PRED,             /* horizontal prediction */
      79                 :     TM_PRED,            /* Truemotion prediction */
      80                 :     B_PRED,             /* block based prediction, each block has its own prediction mode */
      81                 : 
      82                 :     NEARESTMV,
      83                 :     NEARMV,
      84                 :     ZEROMV,
      85                 :     NEWMV,
      86                 :     SPLITMV,
      87                 : 
      88                 :     MB_MODE_COUNT
      89                 : } MB_PREDICTION_MODE;
      90                 : 
      91                 : /* Macroblock level features */
      92                 : typedef enum
      93                 : {
      94                 :     MB_LVL_ALT_Q = 0,               /* Use alternate Quantizer .... */
      95                 :     MB_LVL_ALT_LF = 1,              /* Use alternate loop filter value... */
      96                 :     MB_LVL_MAX = 2                  /* Number of MB level features supported */
      97                 : 
      98                 : } MB_LVL_FEATURES;
      99                 : 
     100                 : /* Segment Feature Masks */
     101                 : #define SEGMENT_ALTQ    0x01
     102                 : #define SEGMENT_ALT_LF  0x02
     103                 : 
     104                 : #define VP8_YMODES  (B_PRED + 1)
     105                 : #define VP8_UV_MODES (TM_PRED + 1)
     106                 : 
     107                 : #define VP8_MVREFS (1 + SPLITMV - NEARESTMV)
     108                 : 
     109                 : typedef enum
     110                 : {
     111                 :     B_DC_PRED,          /* average of above and left pixels */
     112                 :     B_TM_PRED,
     113                 : 
     114                 :     B_VE_PRED,           /* vertical prediction */
     115                 :     B_HE_PRED,           /* horizontal prediction */
     116                 : 
     117                 :     B_LD_PRED,
     118                 :     B_RD_PRED,
     119                 : 
     120                 :     B_VR_PRED,
     121                 :     B_VL_PRED,
     122                 :     B_HD_PRED,
     123                 :     B_HU_PRED,
     124                 : 
     125                 :     LEFT4X4,
     126                 :     ABOVE4X4,
     127                 :     ZERO4X4,
     128                 :     NEW4X4,
     129                 : 
     130                 :     B_MODE_COUNT
     131                 : } B_PREDICTION_MODE;
     132                 : 
     133                 : #define VP8_BINTRAMODES (B_HU_PRED + 1)  /* 10 */
     134                 : #define VP8_SUBMVREFS (1 + NEW4X4 - LEFT4X4)
     135                 : 
     136                 : /* For keyframes, intra block modes are predicted by the (already decoded)
     137                 :    modes for the Y blocks to the left and above us; for interframes, there
     138                 :    is a single probability table. */
     139                 : 
     140                 : union b_mode_info
     141                 : {
     142                 :     B_PREDICTION_MODE as_mode;
     143                 :     int_mv mv;
     144                 : };
     145                 : 
     146                 : typedef enum
     147                 : {
     148                 :     INTRA_FRAME = 0,
     149                 :     LAST_FRAME = 1,
     150                 :     GOLDEN_FRAME = 2,
     151                 :     ALTREF_FRAME = 3,
     152                 :     MAX_REF_FRAMES = 4
     153                 : } MV_REFERENCE_FRAME;
     154                 : 
     155                 : typedef struct
     156                 : {
     157                 :     MB_PREDICTION_MODE mode, uv_mode;
     158                 :     MV_REFERENCE_FRAME ref_frame;
     159                 :     int_mv mv;
     160                 : 
     161                 :     unsigned char partitioning;
     162                 :     unsigned char mb_skip_coeff;                                /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
     163                 :     unsigned char need_to_clamp_mvs;
     164                 :     unsigned char segment_id;                  /* Which set of segmentation parameters should be used for this MB */
     165                 : } MB_MODE_INFO;
     166                 : 
     167                 : typedef struct
     168                 : {
     169                 :     MB_MODE_INFO mbmi;
     170                 :     union b_mode_info bmi[16];
     171                 : } MODE_INFO;
     172                 : 
     173                 : typedef struct
     174                 : {
     175                 :     short *qcoeff;
     176                 :     short *dqcoeff;
     177                 :     unsigned char  *predictor;
     178                 :     short *diff;
     179                 :     short *dequant;
     180                 : 
     181                 :     /* 16 Y blocks, 4 U blocks, 4 V blocks each with 16 entries */
     182                 :     unsigned char **base_pre;
     183                 :     int pre;
     184                 :     int pre_stride;
     185                 : 
     186                 :     unsigned char **base_dst;
     187                 :     int dst;
     188                 :     int dst_stride;
     189                 : 
     190                 :     int eob;
     191                 : 
     192                 :     union b_mode_info bmi;
     193                 : } BLOCKD;
     194                 : 
     195                 : typedef struct MacroBlockD
     196                 : {
     197                 :     DECLARE_ALIGNED(16, short, diff[400]);      /* from idct diff */
     198                 :     DECLARE_ALIGNED(16, unsigned char,  predictor[384]);
     199                 :     DECLARE_ALIGNED(16, short, qcoeff[400]);
     200                 :     DECLARE_ALIGNED(16, short, dqcoeff[400]);
     201                 :     DECLARE_ALIGNED(16, char,  eobs[25]);
     202                 : 
     203                 :     /* 16 Y blocks, 4 U, 4 V, 1 DC 2nd order block, each with 16 entries. */
     204                 :     BLOCKD block[25];
     205                 : 
     206                 :     YV12_BUFFER_CONFIG pre; /* Filtered copy of previous frame reconstruction */
     207                 :     YV12_BUFFER_CONFIG dst;
     208                 : 
     209                 :     MODE_INFO *mode_info_context;
     210                 :     int mode_info_stride;
     211                 : 
     212                 :     FRAME_TYPE frame_type;
     213                 : 
     214                 :     int up_available;
     215                 :     int left_available;
     216                 : 
     217                 :     /* Y,U,V,Y2 */
     218                 :     ENTROPY_CONTEXT_PLANES *above_context;
     219                 :     ENTROPY_CONTEXT_PLANES *left_context;
     220                 : 
     221                 :     /* 0 indicates segmentation at MB level is not enabled. Otherwise the individual bits indicate which features are active. */
     222                 :     unsigned char segmentation_enabled;
     223                 : 
     224                 :     /* 0 (do not update) 1 (update) the macroblock segmentation map. */
     225                 :     unsigned char update_mb_segmentation_map;
     226                 : 
     227                 :     /* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
     228                 :     unsigned char update_mb_segmentation_data;
     229                 : 
     230                 :     /* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
     231                 :     unsigned char mb_segement_abs_delta;
     232                 : 
     233                 :     /* Per frame flags that define which MB level features (such as quantizer or loop filter level) */
     234                 :     /* are enabled and when enabled the proabilities used to decode the per MB flags in MB_MODE_INFO */
     235                 :     vp8_prob mb_segment_tree_probs[MB_FEATURE_TREE_PROBS];         /* Probability Tree used to code Segment number */
     236                 : 
     237                 :     signed char segment_feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];            /* Segment parameters */
     238                 : 
     239                 :     /* mode_based Loop filter adjustment */
     240                 :     unsigned char mode_ref_lf_delta_enabled;
     241                 :     unsigned char mode_ref_lf_delta_update;
     242                 : 
     243                 :     /* Delta values have the range +/- MAX_LOOP_FILTER */
     244                 :     signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];                /* 0 = Intra, Last, GF, ARF */
     245                 :     signed char ref_lf_deltas[MAX_REF_LF_DELTAS];                     /* 0 = Intra, Last, GF, ARF */
     246                 :     signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];                      /* 0 = BPRED, ZERO_MV, MV, SPLIT */
     247                 :     signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];                           /* 0 = BPRED, ZERO_MV, MV, SPLIT */
     248                 : 
     249                 :     /* Distance of MB away from frame edges */
     250                 :     int mb_to_left_edge;
     251                 :     int mb_to_right_edge;
     252                 :     int mb_to_top_edge;
     253                 :     int mb_to_bottom_edge;
     254                 : 
     255                 :     int ref_frame_cost[MAX_REF_FRAMES];
     256                 : 
     257                 : 
     258                 :     unsigned int frames_since_golden;
     259                 :     unsigned int frames_till_alt_ref_frame;
     260                 :     vp8_subpix_fn_t  subpixel_predict;
     261                 :     vp8_subpix_fn_t  subpixel_predict8x4;
     262                 :     vp8_subpix_fn_t  subpixel_predict8x8;
     263                 :     vp8_subpix_fn_t  subpixel_predict16x16;
     264                 : 
     265                 :     void *current_bc;
     266                 : 
     267                 :     int corrupted;
     268                 : 
     269                 : #if ARCH_X86 || ARCH_X86_64
     270                 :     /* This is an intermediate buffer currently used in sub-pixel motion search
     271                 :      * to keep a copy of the reference area. This buffer can be used for other
     272                 :      * purpose.
     273                 :      */
     274                 :     DECLARE_ALIGNED(32, unsigned char, y_buf[22*32]);
     275                 : #endif
     276                 : 
     277                 : #if CONFIG_RUNTIME_CPU_DETECT
     278                 :     struct VP8_COMMON_RTCD  *rtcd;
     279                 : #endif
     280                 : } MACROBLOCKD;
     281                 : 
     282                 : 
     283                 : extern void vp8_build_block_doffsets(MACROBLOCKD *x);
     284                 : extern void vp8_setup_block_dptrs(MACROBLOCKD *x);
     285                 : 
     286               0 : static void update_blockd_bmi(MACROBLOCKD *xd)
     287                 : {
     288                 :     int i;
     289                 :     int is_4x4;
     290               0 :     is_4x4 = (xd->mode_info_context->mbmi.mode == SPLITMV) ||
     291               0 :               (xd->mode_info_context->mbmi.mode == B_PRED);
     292                 : 
     293               0 :     if (is_4x4)
     294                 :     {
     295               0 :         for (i = 0; i < 16; i++)
     296                 :         {
     297               0 :             xd->block[i].bmi = xd->mode_info_context->bmi[i];
     298                 :         }
     299                 :     }
     300               0 : }
     301                 : 
     302                 : #endif  /* __INC_BLOCKD_H */

Generated by: LCOV version 1.7