encoder/macroblock.h

   1 /*****************************************************************************
   2  * macroblock.h: macroblock encoding
   3  *****************************************************************************
   4  * Copyright (C) 2003-2017 x264 project
   5  *
   6  * Authors: Loren Merritt <lorenm@u.washington.edu>
   7  *          Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22  *
  23  * This program is also available under a commercial proprietary license.
  24  * For more information, contact us at licensing@x264.com.
  25  *****************************************************************************/
  26
  27 #ifndef X264_ENCODER_MACROBLOCK_H
  28 #define X264_ENCODER_MACROBLOCK_H
  29
  30 #include "common/macroblock.h"
  31
  32 extern const int x264_lambda2_tab[QP_MAX_MAX+1];
  33 extern const uint16_t x264_lambda_tab[QP_MAX_MAX+1];
  34
  35 void x264_rdo_init( void );
  36
  37 int x264_macroblock_probe_skip( x264_t *h, int b_bidir );
  38
  39 #define x264_macroblock_probe_pskip( h )\
  40     x264_macroblock_probe_skip( h, 0 )
  41 #define x264_macroblock_probe_bskip( h )\
  42     x264_macroblock_probe_skip( h, 1 )
  43
  44 void x264_predict_lossless_4x4( x264_t *h, pixel *p_dst, int p, int idx, int i_mode );
  45 void x264_predict_lossless_8x8( x264_t *h, pixel *p_dst, int p, int idx, int i_mode, pixel edge[36] );
  46 void x264_predict_lossless_16x16( x264_t *h, int p, int i_mode );
  47 void x264_predict_lossless_chroma( x264_t *h, int i_mode );
  48
  49 void x264_macroblock_encode      ( x264_t *h );
  50 void x264_macroblock_write_cabac ( x264_t *h, x264_cabac_t *cb );
  51 void x264_macroblock_write_cavlc ( x264_t *h );
  52
  53 void x264_macroblock_encode_p8x8( x264_t *h, int i8 );
  54 void x264_macroblock_encode_p4x4( x264_t *h, int i4 );
  55 void x264_mb_encode_chroma( x264_t *h, int b_inter, int i_qp );
  56
  57 void x264_cabac_mb_skip( x264_t *h, int b_skip );
  58 void x264_cabac_block_residual_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l );
  59 void x264_cabac_block_residual_8x8_rd_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l );
  60 void x264_cabac_block_residual_rd_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l );
  61
  62 int x264_quant_luma_dc_trellis( x264_t *h, dctcoef *dct, int i_quant_cat, int i_qp,
  63                                 int ctx_block_cat, int b_intra, int idx );
  64 int x264_quant_chroma_dc_trellis( x264_t *h, dctcoef *dct, int i_qp, int b_intra, int idx );
  65 int x264_quant_4x4_trellis( x264_t *h, dctcoef *dct, int i_quant_cat,
  66                              int i_qp, int ctx_block_cat, int b_intra, int b_chroma, int idx );
  67 int x264_quant_8x8_trellis( x264_t *h, dctcoef *dct, int i_quant_cat,
  68                              int i_qp, int ctx_block_cat, int b_intra, int b_chroma, int idx );
  69
  70 void x264_noise_reduction_update( x264_t *h );
  71
  72 static ALWAYS_INLINE int x264_quant_4x4( x264_t *h, dctcoef dct[16], int i_qp, int ctx_block_cat, int b_intra, int p, int idx )
  73 {
  74     int i_quant_cat = b_intra ? (p?CQM_4IC:CQM_4IY) : (p?CQM_4PC:CQM_4PY);
  75     if( h->mb.b_noise_reduction )
  76         h->quantf.denoise_dct( dct, h->nr_residual_sum[0+!!p*2], h->nr_offset[0+!!p*2], 16 );
  77     if( h->mb.b_trellis )
  78         return x264_quant_4x4_trellis( h, dct, i_quant_cat, i_qp, ctx_block_cat, b_intra, !!p, idx+p*16 );
  79     else
  80         return h->quantf.quant_4x4( dct, h->quant4_mf[i_quant_cat][i_qp], h->quant4_bias[i_quant_cat][i_qp] );
  81 }
  82
  83 static ALWAYS_INLINE int x264_quant_8x8( x264_t *h, dctcoef dct[64], int i_qp, int ctx_block_cat, int b_intra, int p, int idx )
  84 {
  85     int i_quant_cat = b_intra ? (p?CQM_8IC:CQM_8IY) : (p?CQM_8PC:CQM_8PY);
  86     if( h->mb.b_noise_reduction )
  87         h->quantf.denoise_dct( dct, h->nr_residual_sum[1+!!p*2], h->nr_offset[1+!!p*2], 64 );
  88     if( h->mb.b_trellis )
  89         return x264_quant_8x8_trellis( h, dct, i_quant_cat, i_qp, ctx_block_cat, b_intra, !!p, idx+p*4 );
  90     else
  91         return h->quantf.quant_8x8( dct, h->quant8_mf[i_quant_cat][i_qp], h->quant8_bias[i_quant_cat][i_qp] );
  92 }
  93
  94 #define STORE_8x8_NNZ( p, idx, nz )\
  95 do\
  96 {\
  97     M16( &h->mb.cache.non_zero_count[x264_scan8[p*16+idx*4]+0] ) = (nz) * 0x0101;\
  98     M16( &h->mb.cache.non_zero_count[x264_scan8[p*16+idx*4]+8] ) = (nz) * 0x0101;\
  99 } while( 0 )
 100
 101 #define CLEAR_16x16_NNZ( p ) \
 102 do\
 103 {\
 104     M32( &h->mb.cache.non_zero_count[x264_scan8[16*p] + 0*8] ) = 0;\
 105     M32( &h->mb.cache.non_zero_count[x264_scan8[16*p] + 1*8] ) = 0;\
 106     M32( &h->mb.cache.non_zero_count[x264_scan8[16*p] + 2*8] ) = 0;\
 107     M32( &h->mb.cache.non_zero_count[x264_scan8[16*p] + 3*8] ) = 0;\
 108 } while( 0 )
 109
 110 /* A special for loop that iterates branchlessly over each set
 111  * bit in a 4-bit input. */
 112 #define FOREACH_BIT(idx,start,mask) for( int idx = start, msk = mask, skip; msk && (skip = x264_ctz_4bit(msk), idx += skip, msk >>= skip+1, 1); idx++ )
 113
 114 static ALWAYS_INLINE void x264_mb_encode_i4x4( x264_t *h, int p, int idx, int i_qp, int i_mode, int b_predict )
 115 {
 116     int nz;
 117     pixel *p_src = &h->mb.pic.p_fenc[p][block_idx_xy_fenc[idx]];
 118     pixel *p_dst = &h->mb.pic.p_fdec[p][block_idx_xy_fdec[idx]];
 119     ALIGNED_ARRAY_64( dctcoef, dct4x4,[16] );
 120
 121     if( b_predict )
 122     {
 123         if( h->mb.b_lossless )
 124             x264_predict_lossless_4x4( h, p_dst, p, idx, i_mode );
 125         else
 126             h->predict_4x4[i_mode]( p_dst );
 127     }
 128
 129     if( h->mb.b_lossless )
 130     {
 131         nz = h->zigzagf.sub_4x4( h->dct.luma4x4[p*16+idx], p_src, p_dst );
 132         h->mb.cache.non_zero_count[x264_scan8[p*16+idx]] = nz;
 133         h->mb.i_cbp_luma |= nz<<(idx>>2);
 134         return;
 135     }
 136
 137     h->dctf.sub4x4_dct( dct4x4, p_src, p_dst );
 138
 139     nz = x264_quant_4x4( h, dct4x4, i_qp, ctx_cat_plane[DCT_LUMA_4x4][p], 1, p, idx );
 140     h->mb.cache.non_zero_count[x264_scan8[p*16+idx]] = nz;
 141     if( nz )
 142     {
 143         h->mb.i_cbp_luma |= 1<<(idx>>2);
 144         h->zigzagf.scan_4x4( h->dct.luma4x4[p*16+idx], dct4x4 );
 145         h->quantf.dequant_4x4( dct4x4, h->dequant4_mf[p?CQM_4IC:CQM_4IY], i_qp );
 146         h->dctf.add4x4_idct( p_dst, dct4x4 );
 147     }
 148 }
 149
 150 static ALWAYS_INLINE void x264_mb_encode_i8x8( x264_t *h, int p, int idx, int i_qp, int i_mode, pixel *edge, int b_predict )
 151 {
 152     int x = idx&1;
 153     int y = idx>>1;
 154     int nz;
 155     pixel *p_src = &h->mb.pic.p_fenc[p][8*x + 8*y*FENC_STRIDE];
 156     pixel *p_dst = &h->mb.pic.p_fdec[p][8*x + 8*y*FDEC_STRIDE];
 157     ALIGNED_ARRAY_64( dctcoef, dct8x8,[64] );
 158     ALIGNED_ARRAY_32( pixel, edge_buf,[36] );
 159
 160     if( b_predict )
 161     {
 162         if( !edge )
 163         {
 164             h->predict_8x8_filter( p_dst, edge_buf, h->mb.i_neighbour8[idx], x264_pred_i4x4_neighbors[i_mode] );
 165             edge = edge_buf;
 166         }
 167
 168         if( h->mb.b_lossless )
 169             x264_predict_lossless_8x8( h, p_dst, p, idx, i_mode, edge );
 170         else
 171             h->predict_8x8[i_mode]( p_dst, edge );
 172     }
 173
 174     if( h->mb.b_lossless )
 175     {
 176         nz = h->zigzagf.sub_8x8( h->dct.luma8x8[p*4+idx], p_src, p_dst );
 177         STORE_8x8_NNZ( p, idx, nz );
 178         h->mb.i_cbp_luma |= nz<<idx;
 179         return;
 180     }
 181
 182     h->dctf.sub8x8_dct8( dct8x8, p_src, p_dst );
 183
 184     nz = x264_quant_8x8( h, dct8x8, i_qp, ctx_cat_plane[DCT_LUMA_8x8][p], 1, p, idx );
 185     if( nz )
 186     {
 187         h->mb.i_cbp_luma |= 1<<idx;
 188         h->zigzagf.scan_8x8( h->dct.luma8x8[p*4+idx], dct8x8 );
 189         h->quantf.dequant_8x8( dct8x8, h->dequant8_mf[p?CQM_8IC:CQM_8IY], i_qp );
 190         h->dctf.add8x8_idct8( p_dst, dct8x8 );
 191         STORE_8x8_NNZ( p, idx, 1 );
 192     }
 193     else
 194         STORE_8x8_NNZ( p, idx, 0 );
 195 }
 196
 197 #endif
 198