开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
macroblock.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：45k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

macroblock.c：源码内容
  1. /*****************************************************************************
  2.  * macroblock.c: h264 encoder library
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  7.  *          Loren Merritt <lorenm@u.washington.edu>
  8.  *          Jason Garrett-Glaser <darkshikari@gmail.com>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. #include "common/common.h"
  26. #include "macroblock.h"
  28. /* These chroma DC functions don't have assembly versions and are only used here. */
  30. #define ZIG(i,y,x) level[i] = dct[x][y];
  31. static inline void zigzag_scan_2x2_dc( int16_t level[4], int16_t dct[2][2] )
  32. {
  33.     ZIG(0,0,0)
  34.     ZIG(1,0,1)
  35.     ZIG(2,1,0)
  36.     ZIG(3,1,1)
  37. }
  38. #undef ZIG
  40. #define IDCT_DEQUANT_START 
  41.     int d0 = dct[0][0] + dct[0][1]; 
  42.     int d1 = dct[1][0] + dct[1][1]; 
  43.     int d2 = dct[0][0] - dct[0][1]; 
  44.     int d3 = dct[1][0] - dct[1][1]; 
  45.     int dmf = dequant_mf[i_qp%6][0][0]; 
  46.     int qbits = i_qp/6 - 5; 
  47.     if( qbits > 0 ) 
  48.     { 
  49.         dmf <<= qbits; 
  50.         qbits = 0; 
  51.     }
  53. static inline void idct_dequant_2x2_dc( int16_t dct[2][2], int16_t dct4x4[4][4][4], int dequant_mf[6][4][4], int i_qp )
  54. {
  55.     IDCT_DEQUANT_START
  56.     dct4x4[0][0][0] = (d0 + d1) * dmf >> -qbits;
  57.     dct4x4[1][0][0] = (d0 - d1) * dmf >> -qbits;
  58.     dct4x4[2][0][0] = (d2 + d3) * dmf >> -qbits;
  59.     dct4x4[3][0][0] = (d2 - d3) * dmf >> -qbits;
  60. }
  62. static inline void idct_dequant_2x2_dconly( int16_t out[2][2], int16_t dct[2][2], int dequant_mf[6][4][4], int i_qp )
  63. {
  64.     IDCT_DEQUANT_START
  65.     out[0][0] = (d0 + d1) * dmf >> -qbits;
  66.     out[0][1] = (d0 - d1) * dmf >> -qbits;
  67.     out[1][0] = (d2 + d3) * dmf >> -qbits;
  68.     out[1][1] = (d2 - d3) * dmf >> -qbits;
  69. }
  71. static inline void dct2x2dc( int16_t d[2][2], int16_t dct4x4[4][4][4] )
  72. {
  73.     int d0 = dct4x4[0][0][0] + dct4x4[1][0][0];
  74.     int d1 = dct4x4[2][0][0] + dct4x4[3][0][0];
  75.     int d2 = dct4x4[0][0][0] - dct4x4[1][0][0];
  76.     int d3 = dct4x4[2][0][0] - dct4x4[3][0][0];
  77.     d[0][0] = d0 + d1;
  78.     d[1][0] = d2 + d3;
  79.     d[0][1] = d0 - d1;
  80.     d[1][1] = d2 - d3;
  81.     dct4x4[0][0][0] = 0;
  82.     dct4x4[1][0][0] = 0;
  83.     dct4x4[2][0][0] = 0;
  84.     dct4x4[3][0][0] = 0;
  85. }
  87. static inline void dct2x2dc_dconly( int16_t d[2][2] )
  88. {
  89.     int d0 = d[0][0] + d[0][1];
  90.     int d1 = d[1][0] + d[1][1];
  91.     int d2 = d[0][0] - d[0][1];
  92.     int d3 = d[1][0] - d[1][1];
  93.     d[0][0] = d0 + d1;
  94.     d[1][0] = d2 + d3;
  95.     d[0][1] = d0 - d1;
  96.     d[1][1] = d2 - d3;
  97. }
  99. static ALWAYS_INLINE int x264_quant_4x4( x264_t *h, int16_t dct[4][4], int i_qp, int i_ctxBlockCat, int b_intra, int idx )
  100. {
  101.     int i_quant_cat = b_intra ? CQM_4IY : CQM_4PY;
  102.     if( h->mb.b_trellis )
  103.         return x264_quant_4x4_trellis( h, dct, i_quant_cat, i_qp, i_ctxBlockCat, b_intra, 0, idx );
  104.     else
  105.         return h->quantf.quant_4x4( dct, h->quant4_mf[i_quant_cat][i_qp], h->quant4_bias[i_quant_cat][i_qp] );
  106. }
  108. static ALWAYS_INLINE int x264_quant_8x8( x264_t *h, int16_t dct[8][8], int i_qp, int b_intra, int idx )
  109. {
  110.     int i_quant_cat = b_intra ? CQM_8IY : CQM_8PY;
  111.     if( h->mb.b_trellis )
  112.         return x264_quant_8x8_trellis( h, dct, i_quant_cat, i_qp, b_intra, idx );
  113.     else
  114.         return h->quantf.quant_8x8( dct, h->quant8_mf[i_quant_cat][i_qp], h->quant8_bias[i_quant_cat][i_qp] );
  115. }
  117. /* All encoding functions must output the correct CBP and NNZ values.
  118.  * The entropy coding functions will check CBP first, then NNZ, before
  119.  * actually reading the DCT coefficients.  NNZ still must be correct even
  120.  * if CBP is zero because of the use of NNZ values for context selection.
  121.  * "NNZ" need only be 0 or 1 rather than the exact coefficient count because
  122.  * that is only needed in CAVLC, and will be calculated by CAVLC's residual
  123.  * coding and stored as necessary. */
  125. /* This means that decimation can be done merely by adjusting the CBP and NNZ
  126.  * rather than memsetting the coefficients. */
  128. void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qp )
  129. {
  130.     int nz;
  131.     uint8_t *p_src = &h->mb.pic.p_fenc[0][block_idx_xy_fenc[idx]];
  132.     uint8_t *p_dst = &h->mb.pic.p_fdec[0][block_idx_xy_fdec[idx]];
  133.     ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4] );
  135.     if( h->mb.b_lossless )
  136.     {
  137.         nz = h->zigzagf.sub_4x4( h->dct.luma4x4[idx], p_src, p_dst );
  138.         h->mb.cache.non_zero_count[x264_scan8[idx]] = nz;
  139.         h->mb.i_cbp_luma |= nz<<(idx>>2);
  140.         return;
  141.     }
  143.     h->dctf.sub4x4_dct( dct4x4, p_src, p_dst );
  145.     nz = x264_quant_4x4( h, dct4x4, i_qp, DCT_LUMA_4x4, 1, idx );
  146.     h->mb.cache.non_zero_count[x264_scan8[idx]] = nz;
  147.     if( nz )
  148.     {
  149.         h->mb.i_cbp_luma |= 1<<(idx>>2);
  150.         h->zigzagf.scan_4x4( h->dct.luma4x4[idx], dct4x4 );
  151.         h->quantf.dequant_4x4( dct4x4, h->dequant4_mf[CQM_4IY], i_qp );
  152.         h->dctf.add4x4_idct( p_dst, dct4x4 );
  153.     }
  154. }
  156. #define STORE_8x8_NNZ(idx,nz)
  157. {
  158.     *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[idx*4+0]] = nz * 0x0101;
  159.     *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[idx*4+2]] = nz * 0x0101;
  160. }
  162. void x264_mb_encode_i8x8( x264_t *h, int idx, int i_qp )
  163. {
  164.     int x = 8 * (idx&1);
  165.     int y = 8 * (idx>>1);
  166.     int nz;
  167.     uint8_t *p_src = &h->mb.pic.p_fenc[0][x+y*FENC_STRIDE];
  168.     uint8_t *p_dst = &h->mb.pic.p_fdec[0][x+y*FDEC_STRIDE];
  169.     ALIGNED_ARRAY_16( int16_t, dct8x8,[8],[8] );
  171.     if( h->mb.b_lossless )
  172.     {
  173.         nz = h->zigzagf.sub_8x8( h->dct.luma8x8[idx], p_src, p_dst );
  174.         STORE_8x8_NNZ(idx,nz);
  175.         h->mb.i_cbp_luma |= nz<<idx;
  176.         return;
  177.     }
  179.     h->dctf.sub8x8_dct8( dct8x8, p_src, p_dst );
  181.     nz = x264_quant_8x8( h, dct8x8, i_qp, 1, idx );
  182.     if( nz )
  183.     {
  184.         h->mb.i_cbp_luma |= 1<<idx;
  185.         h->zigzagf.scan_8x8( h->dct.luma8x8[idx], dct8x8 );
  186.         h->quantf.dequant_8x8( dct8x8, h->dequant8_mf[CQM_8IY], i_qp );
  187.         h->dctf.add8x8_idct8( p_dst, dct8x8 );
  188.         STORE_8x8_NNZ(idx,1);
  189.     }
  190.     else
  191.         STORE_8x8_NNZ(idx,0);
  192. }
  194. static void x264_mb_encode_i16x16( x264_t *h, int i_qp )
  195. {
  196.     uint8_t  *p_src = h->mb.pic.p_fenc[0];
  197.     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
  199.     ALIGNED_ARRAY_16( int16_t, dct4x4,[16],[4][4] );
  200.     ALIGNED_ARRAY_16( int16_t, dct_dc4x4,[4],[4] );
  202.     int i, nz;
  203.     int b_decimate = h->sh.i_type == SLICE_TYPE_B || (h->param.analyse.b_dct_decimate && h->sh.i_type == SLICE_TYPE_P);
  204.     int decimate_score = b_decimate ? 0 : 9;
  206.     if( h->mb.b_lossless )
  207.     {
  208.         for( i = 0; i < 16; i++ )
  209.         {
  210.             int oe = block_idx_xy_fenc[i];
  211.             int od = block_idx_xy_fdec[i];
  212.             nz = h->zigzagf.sub_4x4ac( h->dct.luma4x4[i], p_src+oe, p_dst+od, &dct_dc4x4[0][block_idx_yx_1d[i]] );
  213.             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
  214.             h->mb.i_cbp_luma |= nz;
  215.         }
  216.         h->mb.i_cbp_luma *= 0xf;
  217.         h->mb.cache.non_zero_count[x264_scan8[24]] = array_non_zero( dct_dc4x4 );
  218.         h->zigzagf.scan_4x4( h->dct.luma16x16_dc, dct_dc4x4 );
  219.         return;
  220.     }
  222.     h->dctf.sub16x16_dct( dct4x4, p_src, p_dst );
  224.     for( i = 0; i < 16; i++ )
  225.     {
  226.         /* copy dc coeff */
  227.         dct_dc4x4[0][block_idx_xy_1d[i]] = dct4x4[i][0][0];
  228.         dct4x4[i][0][0] = 0;
  230.         /* quant/scan/dequant */
  231.         nz = x264_quant_4x4( h, dct4x4[i], i_qp, DCT_LUMA_AC, 1, i );
  232.         h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
  233.         if( nz )
  234.         {
  235.             h->zigzagf.scan_4x4( h->dct.luma4x4[i], dct4x4[i] );
  236.             h->quantf.dequant_4x4( dct4x4[i], h->dequant4_mf[CQM_4IY], i_qp );
  237.             if( decimate_score < 6 ) decimate_score += h->quantf.decimate_score15( h->dct.luma4x4[i] );
  238.             h->mb.i_cbp_luma = 0xf;
  239.         }
  240.     }
  242.     /* Writing the 16 CBFs in an i16x16 block is quite costly, so decimation can save many bits. */
  243.     /* More useful with CAVLC, but still useful with CABAC. */
  244.     if( decimate_score < 6 )
  245.     {
  246.         h->mb.i_cbp_luma = 0;
  247.         *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]] = 0;
  248.         *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]] = 0;
  249.         *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]] = 0;
  250.         *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]] = 0;
  251.     }
  253.     h->dctf.dct4x4dc( dct_dc4x4 );
  254.     if( h->mb.b_trellis )
  255.         nz = x264_quant_dc_trellis( h, (int16_t*)dct_dc4x4, CQM_4IY, i_qp, DCT_LUMA_DC, 1, 0 );
  256.     else
  257.         nz = h->quantf.quant_4x4_dc( dct_dc4x4, h->quant4_mf[CQM_4IY][i_qp][0]>>1, h->quant4_bias[CQM_4IY][i_qp][0]<<1 );
  259.     h->mb.cache.non_zero_count[x264_scan8[24]] = nz;
  260.     if( nz )
  261.     {
  262.         h->zigzagf.scan_4x4( h->dct.luma16x16_dc, dct_dc4x4 );
  264.         /* output samples to fdec */
  265.         h->dctf.idct4x4dc( dct_dc4x4 );
  266.         h->quantf.dequant_4x4_dc( dct_dc4x4, h->dequant4_mf[CQM_4IY], i_qp );  /* XXX not inversed */
  267.         if( h->mb.i_cbp_luma )
  268.             for( i = 0; i < 16; i++ )
  269.                 dct4x4[i][0][0] = dct_dc4x4[0][block_idx_xy_1d[i]];
  270.     }
  272.     /* put pixels to fdec */
  273.     if( h->mb.i_cbp_luma )
  274.         h->dctf.add16x16_idct( p_dst, dct4x4 );
  275.     else if( nz )
  276.         h->dctf.add16x16_idct_dc( p_dst, dct_dc4x4 );
  277. }
  279. static inline int idct_dequant_round_2x2_dc( int16_t ref[2][2], int16_t dct[2][2], int dequant_mf[6][4][4], int i_qp )
  280. {
  281.     int16_t out[2][2];
  282.     idct_dequant_2x2_dconly( out, dct, dequant_mf, i_qp );
  283.     return ((ref[0][0] ^ (out[0][0]+32))
  284.           | (ref[0][1] ^ (out[0][1]+32))
  285.           | (ref[1][0] ^ (out[1][0]+32))
  286.           | (ref[1][1] ^ (out[1][1]+32))) >> 6;
  287. }
  289. /* Round down coefficients losslessly in DC-only chroma blocks.
  290.  * Unlike luma blocks, this can't be done with a lookup table or
  291.  * other shortcut technique because of the interdependencies
  292.  * between the coefficients due to the chroma DC transform. */
  293. static inline int x264_mb_optimize_chroma_dc( x264_t *h, int b_inter, int i_qp, int16_t dct2x2[2][2] )
  294. {
  295.     int16_t dct2x2_orig[2][2];
  296.     int coeff;
  297.     int nz = 0;
  299.     /* If the QP is too high, there's no benefit to rounding optimization. */
  300.     if( h->dequant4_mf[CQM_4IC + b_inter][i_qp%6][0][0] << (i_qp/6) > 32*64 )
  301.         return 1;
  303.     idct_dequant_2x2_dconly( dct2x2_orig, dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qp );
  304.     dct2x2_orig[0][0] += 32;
  305.     dct2x2_orig[0][1] += 32;
  306.     dct2x2_orig[1][0] += 32;
  307.     dct2x2_orig[1][1] += 32;
  309.     /* If the DC coefficients already round to zero, terminate early. */
  310.     if( !((dct2x2_orig[0][0]|dct2x2_orig[0][1]|dct2x2_orig[1][0]|dct2x2_orig[1][1])>>6) )
  311.         return 0;
  313.     /* Start with the highest frequency coefficient... is this the best option? */
  314.     for( coeff = 3; coeff >= 0; coeff-- )
  315.     {
  316.         int sign = dct2x2[0][coeff] < 0 ? -1 : 1;
  317.         int level = dct2x2[0][coeff];
  319.         if( !level )
  320.             continue;
  322.         while( level )
  323.         {
  324.             dct2x2[0][coeff] = level - sign;
  325.             if( idct_dequant_round_2x2_dc( dct2x2_orig, dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qp ) )
  326.                 break;
  327.             level -= sign;
  328.         }
  330.         nz |= level;
  331.         dct2x2[0][coeff] = level;
  332.     }
  334.     return !!nz;
  335. }
  337. void x264_mb_encode_8x8_chroma( x264_t *h, int b_inter, int i_qp )
  338. {
  339.     int i, ch, nz, nz_dc;
  340.     int b_decimate = b_inter && (h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate);
  341.     ALIGNED_ARRAY_16( int16_t, dct2x2,[2],[2] );
  342.     h->mb.i_cbp_chroma = 0;
  344.     /* Early termination: check variance of chroma residual before encoding.
  345.      * Don't bother trying early termination at low QPs.
  346.      * Values are experimentally derived. */
  347.     if( b_decimate && i_qp >= (h->mb.b_trellis ? 12 : 18) )
  348.     {
  349.         int thresh = (x264_lambda2_tab[i_qp] + 32) >> 6;
  350.         int ssd[2];
  351.         int score  = h->pixf.var2_8x8( h->mb.pic.p_fenc[1], FENC_STRIDE, h->mb.pic.p_fdec[1], FDEC_STRIDE, &ssd[0] );
  352.             score += h->pixf.var2_8x8( h->mb.pic.p_fenc[2], FENC_STRIDE, h->mb.pic.p_fdec[2], FDEC_STRIDE, &ssd[1] );
  353.         if( score < thresh*4 )
  354.         {
  355.             h->mb.cache.non_zero_count[x264_scan8[16]] = 0;
  356.             h->mb.cache.non_zero_count[x264_scan8[17]] = 0;
  357.             h->mb.cache.non_zero_count[x264_scan8[18]] = 0;
  358.             h->mb.cache.non_zero_count[x264_scan8[19]] = 0;
  359.             h->mb.cache.non_zero_count[x264_scan8[20]] = 0;
  360.             h->mb.cache.non_zero_count[x264_scan8[21]] = 0;
  361.             h->mb.cache.non_zero_count[x264_scan8[22]] = 0;
  362.             h->mb.cache.non_zero_count[x264_scan8[23]] = 0;
  363.             h->mb.cache.non_zero_count[x264_scan8[25]] = 0;
  364.             h->mb.cache.non_zero_count[x264_scan8[26]] = 0;
  365.             for( ch = 0; ch < 2; ch++ )
  366.             {
  367.                 if( ssd[ch] > thresh )
  368.                 {
  369.                     h->dctf.sub8x8_dct_dc( dct2x2, h->mb.pic.p_fenc[1+ch], h->mb.pic.p_fdec[1+ch] );
  370.                     dct2x2dc_dconly( dct2x2 );
  371.                     if( h->mb.b_trellis )
  372.                         nz_dc = x264_quant_dc_trellis( h, (int16_t*)dct2x2, CQM_4IC+b_inter, i_qp, DCT_CHROMA_DC, !b_inter, 1 );
  373.                     else
  374.                         nz_dc = h->quantf.quant_2x2_dc( dct2x2, h->quant4_mf[CQM_4IC+b_inter][i_qp][0]>>1, h->quant4_bias[CQM_4IC+b_inter][i_qp][0]<<
  375.     1 );
  377.                     if( nz_dc )
  378.                     {
  379.                         if( !x264_mb_optimize_chroma_dc( h, b_inter, i_qp, dct2x2 ) )
  380.                             continue;
  381.                         h->mb.cache.non_zero_count[x264_scan8[25]+ch] = 1;
  382.                         zigzag_scan_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
  383.                         idct_dequant_2x2_dconly( dct2x2, dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qp );
  384.                         h->dctf.add8x8_idct_dc( h->mb.pic.p_fdec[1+ch], dct2x2 );
  385.                         h->mb.i_cbp_chroma = 1;
  386.                     }
  387.                 }
  388.             }
  389.             return;
  390.         }
  391.     }
  393.     for( ch = 0; ch < 2; ch++ )
  394.     {
  395.         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
  396.         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
  397.         int i_decimate_score = 0;
  398.         int nz_ac = 0;
  400.         ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4][4] );
  402.         if( h->mb.b_lossless )
  403.         {
  404.             for( i = 0; i < 4; i++ )
  405.             {
  406.                 int oe = block_idx_x[i]*4 + block_idx_y[i]*4*FENC_STRIDE;
  407.                 int od = block_idx_x[i]*4 + block_idx_y[i]*4*FDEC_STRIDE;
  408.                 nz = h->zigzagf.sub_4x4ac( h->dct.luma4x4[16+i+ch*4], p_src+oe, p_dst+od, &h->dct.chroma_dc[ch][i] );
  409.                 h->mb.cache.non_zero_count[x264_scan8[16+i+ch*4]] = nz;
  410.                 h->mb.i_cbp_chroma |= nz;
  411.             }
  412.             h->mb.cache.non_zero_count[x264_scan8[25]+ch] = array_non_zero( h->dct.chroma_dc[ch] );
  413.             continue;
  414.         }
  416.         h->dctf.sub8x8_dct( dct4x4, p_src, p_dst );
  417.         dct2x2dc( dct2x2, dct4x4 );
  418.         /* calculate dct coeffs */
  419.         for( i = 0; i < 4; i++ )
  420.         {
  421.             if( h->mb.b_trellis )
  422.                 nz = x264_quant_4x4_trellis( h, dct4x4[i], CQM_4IC+b_inter, i_qp, DCT_CHROMA_AC, !b_inter, 1, 0 );
  423.             else
  424.                 nz = h->quantf.quant_4x4( dct4x4[i], h->quant4_mf[CQM_4IC+b_inter][i_qp], h->quant4_bias[CQM_4IC+b_inter][i_qp] );
  425.             h->mb.cache.non_zero_count[x264_scan8[16+i+ch*4]] = nz;
  426.             if( nz )
  427.             {
  428.                 nz_ac = 1;
  429.                 h->zigzagf.scan_4x4( h->dct.luma4x4[16+i+ch*4], dct4x4[i] );
  430.                 h->quantf.dequant_4x4( dct4x4[i], h->dequant4_mf[CQM_4IC + b_inter], i_qp );
  431.                 if( b_decimate )
  432.                     i_decimate_score += h->quantf.decimate_score15( h->dct.luma4x4[16+i+ch*4] );
  433.             }
  434.         }
  436.         if( h->mb.b_trellis )
  437.             nz_dc = x264_quant_dc_trellis( h, (int16_t*)dct2x2, CQM_4IC+b_inter, i_qp, DCT_CHROMA_DC, !b_inter, 1 );
  438.         else
  439.             nz_dc = h->quantf.quant_2x2_dc( dct2x2, h->quant4_mf[CQM_4IC+b_inter][i_qp][0]>>1, h->quant4_bias[CQM_4IC+b_inter][i_qp][0]<<1 );
  441.         h->mb.cache.non_zero_count[x264_scan8[25]+ch] = nz_dc;
  443.         if( (b_decimate && i_decimate_score < 7) || !nz_ac )
  444.         {
  445.             /* Decimate the block */
  446.             h->mb.cache.non_zero_count[x264_scan8[16+0]+24*ch] = 0;
  447.             h->mb.cache.non_zero_count[x264_scan8[16+1]+24*ch] = 0;
  448.             h->mb.cache.non_zero_count[x264_scan8[16+2]+24*ch] = 0;
  449.             h->mb.cache.non_zero_count[x264_scan8[16+3]+24*ch] = 0;
  450.             if( !nz_dc ) /* Whole block is empty */
  451.                 continue;
  452.             if( !x264_mb_optimize_chroma_dc( h, b_inter, i_qp, dct2x2 ) )
  453.             {
  454.                 h->mb.cache.non_zero_count[x264_scan8[25]+ch] = 0;
  455.                 continue;
  456.             }
  457.             /* DC-only */
  458.             zigzag_scan_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
  459.             idct_dequant_2x2_dconly( dct2x2, dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qp );
  460.             h->dctf.add8x8_idct_dc( p_dst, dct2x2 );
  461.         }
  462.         else
  463.         {
  464.             h->mb.i_cbp_chroma = 1;
  465.             if( nz_dc )
  466.             {
  467.                 zigzag_scan_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
  468.                 idct_dequant_2x2_dc( dct2x2, dct4x4, h->dequant4_mf[CQM_4IC + b_inter], i_qp );
  469.             }
  470.             h->dctf.add8x8_idct( p_dst, dct4x4 );
  471.         }
  472.     }
  474.     if( h->mb.i_cbp_chroma )
  475.         h->mb.i_cbp_chroma = 2;    /* dc+ac (we can't do only ac) */
  476.     else if( h->mb.cache.non_zero_count[x264_scan8[25]] |
  477.              h->mb.cache.non_zero_count[x264_scan8[26]] )
  478.         h->mb.i_cbp_chroma = 1;    /* dc only */
  479. }
  481. static void x264_macroblock_encode_skip( x264_t *h )
  482. {
  483.     h->mb.i_cbp_luma = 0x00;
  484.     h->mb.i_cbp_chroma = 0x00;
  485.     memset( h->mb.cache.non_zero_count, 0, X264_SCAN8_SIZE );
  486.     /* store cbp */
  487.     h->mb.cbp[h->mb.i_mb_xy] = 0;
  488. }
  490. /*****************************************************************************
  491.  * x264_macroblock_encode_pskip:
  492.  *  Encode an already marked skip block
  493.  *****************************************************************************/
  494. static void x264_macroblock_encode_pskip( x264_t *h )
  495. {
  496.     const int mvx = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][0],
  497.                                 h->mb.mv_min[0], h->mb.mv_max[0] );
  498.     const int mvy = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][1],
  499.                                 h->mb.mv_min[1], h->mb.mv_max[1] );
  501.     /* don't do pskip motion compensation if it was already done in macroblock_analyse */
  502.     if( !h->mb.b_skip_mc )
  503.     {
  504.         h->mc.mc_luma( h->mb.pic.p_fdec[0],    FDEC_STRIDE,
  505.                        h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
  506.                        mvx, mvy, 16, 16 );
  508.         h->mc.mc_chroma( h->mb.pic.p_fdec[1],       FDEC_STRIDE,
  509.                          h->mb.pic.p_fref[0][0][4], h->mb.pic.i_stride[1],
  510.                          mvx, mvy, 8, 8 );
  512.         h->mc.mc_chroma( h->mb.pic.p_fdec[2],       FDEC_STRIDE,
  513.                          h->mb.pic.p_fref[0][0][5], h->mb.pic.i_stride[2],
  514.                          mvx, mvy, 8, 8 );
  515.     }
  517.     x264_macroblock_encode_skip( h );
  518. }
  520. /*****************************************************************************
  521.  * Intra prediction for predictive lossless mode.
  522.  *****************************************************************************/
  524. /* Note that these functions take a shortcut (mc.copy instead of actual pixel prediction) which assumes
  525.  * that the edge pixels of the reconstructed frame are the same as that of the source frame.  This means
  526.  * they will only work correctly if the neighboring blocks are losslessly coded.  In practice, this means
  527.  * lossless mode cannot be mixed with lossy mode within a frame. */
  528. /* This can be resolved by explicitly copying the edge pixels after doing the mc.copy, but this doesn't
  529.  * need to be done unless we decide to allow mixing lossless and lossy compression. */
  531. void x264_predict_lossless_8x8_chroma( x264_t *h, int i_mode )
  532. {
  533.     int stride = h->fenc->i_stride[1] << h->mb.b_interlaced;
  534.     if( i_mode == I_PRED_CHROMA_V )
  535.     {
  536.         h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc_plane[1]-stride, stride, 8 );
  537.         h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc_plane[2]-stride, stride, 8 );
  538.     }
  539.     else if( i_mode == I_PRED_CHROMA_H )
  540.     {
  541.         h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc_plane[1]-1, stride, 8 );
  542.         h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc_plane[2]-1, stride, 8 );
  543.     }
  544.     else
  545.     {
  546.         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
  547.         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
  548.     }
  549. }
  551. void x264_predict_lossless_4x4( x264_t *h, uint8_t *p_dst, int idx, int i_mode )
  552. {
  553.     int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
  554.     uint8_t *p_src = h->mb.pic.p_fenc_plane[0] + block_idx_x[idx]*4 + block_idx_y[idx]*4 * stride;
  556.     if( i_mode == I_PRED_4x4_V )
  557.         h->mc.copy[PIXEL_4x4]( p_dst, FDEC_STRIDE, p_src-stride, stride, 4 );
  558.     else if( i_mode == I_PRED_4x4_H )
  559.         h->mc.copy[PIXEL_4x4]( p_dst, FDEC_STRIDE, p_src-1, stride, 4 );
  560.     else
  561.         h->predict_4x4[i_mode]( p_dst );
  562. }
  564. void x264_predict_lossless_8x8( x264_t *h, uint8_t *p_dst, int idx, int i_mode, uint8_t edge[33] )
  565. {
  566.     int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
  567.     uint8_t *p_src = h->mb.pic.p_fenc_plane[0] + (idx&1)*8 + (idx>>1)*8*stride;
  569.     if( i_mode == I_PRED_8x8_V )
  570.         h->mc.copy[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src-stride, stride, 8 );
  571.     else if( i_mode == I_PRED_8x8_H )
  572.         h->mc.copy[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src-1, stride, 8 );
  573.     else
  574.         h->predict_8x8[i_mode]( p_dst, edge );
  575. }
  577. void x264_predict_lossless_16x16( x264_t *h, int i_mode )
  578. {
  579.     int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
  580.     if( i_mode == I_PRED_16x16_V )
  581.         h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc_plane[0]-stride, stride, 16 );
  582.     else if( i_mode == I_PRED_16x16_H )
  583.         h->mc.copy_16x16_unaligned( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc_plane[0]-1, stride, 16 );
  584.     else
  585.         h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0] );
  586. }
  588. /*****************************************************************************
  589.  * x264_macroblock_encode:
  590.  *****************************************************************************/
  591. void x264_macroblock_encode( x264_t *h )
  592. {
  593.     int i_cbp_dc = 0;
  594.     int i_qp = h->mb.i_qp;
  595.     int b_decimate = h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate;
  596.     int b_force_no_skip = 0;
  597.     int i,idx,nz;
  598.     h->mb.i_cbp_luma = 0;
  599.     h->mb.cache.non_zero_count[x264_scan8[24]] = 0;
  601.     if( h->sh.b_mbaff
  602.         && h->mb.i_mb_xy == h->sh.i_first_mb + h->mb.i_mb_stride
  603.         && IS_SKIP(h->mb.type[h->sh.i_first_mb]) )
  604.     {
  605.         /* The first skip is predicted to be a frame mb pair.
  606.          * We don't yet support the aff part of mbaff, so force it to non-skip
  607.          * so that we can pick the aff flag. */
  608.         b_force_no_skip = 1;
  609.         if( IS_SKIP(h->mb.i_type) )
  610.         {
  611.             if( h->mb.i_type == P_SKIP )
  612.                 h->mb.i_type = P_L0;
  613.             else if( h->mb.i_type == B_SKIP )
  614.                 h->mb.i_type = B_DIRECT;
  615.         }
  616.     }
  618.     if( h->mb.i_type == P_SKIP )
  619.     {
  620.         /* A bit special */
  621.         x264_macroblock_encode_pskip( h );
  622.         return;
  623.     }
  624.     if( h->mb.i_type == B_SKIP )
  625.     {
  626.         /* don't do bskip motion compensation if it was already done in macroblock_analyse */
  627.         if( !h->mb.b_skip_mc )
  628.             x264_mb_mc( h );
  629.         x264_macroblock_encode_skip( h );
  630.         return;
  631.     }
  633.     if( h->mb.i_type == I_16x16 )
  634.     {
  635.         const int i_mode = h->mb.i_intra16x16_pred_mode;
  636.         h->mb.b_transform_8x8 = 0;
  638.         if( h->mb.b_lossless )
  639.             x264_predict_lossless_16x16( h, i_mode );
  640.         else
  641.             h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0] );
  643.         /* encode the 16x16 macroblock */
  644.         x264_mb_encode_i16x16( h, i_qp );
  645.     }
  646.     else if( h->mb.i_type == I_8x8 )
  647.     {
  648.         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
  649.         h->mb.b_transform_8x8 = 1;
  650.         /* If we already encoded 3 of the 4 i8x8 blocks, we don't have to do them again. */
  651.         if( h->mb.i_skip_intra )
  652.         {
  653.             h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i8x8_fdec_buf, 16, 16 );
  654.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]] = h->mb.pic.i8x8_nnz_buf[0];
  655.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]] = h->mb.pic.i8x8_nnz_buf[1];
  656.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]] = h->mb.pic.i8x8_nnz_buf[2];
  657.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]] = h->mb.pic.i8x8_nnz_buf[3];
  658.             h->mb.i_cbp_luma = h->mb.pic.i8x8_cbp;
  659.             /* In RD mode, restore the now-overwritten DCT data. */
  660.             if( h->mb.i_skip_intra == 2 )
  661.                 h->mc.memcpy_aligned( h->dct.luma8x8, h->mb.pic.i8x8_dct_buf, sizeof(h->mb.pic.i8x8_dct_buf) );
  662.         }
  663.         for( i = h->mb.i_skip_intra ? 3 : 0 ; i < 4; i++ )
  664.         {
  665.             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][8 * (i&1) + 8 * (i>>1) * FDEC_STRIDE];
  666.             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]];
  667.             h->predict_8x8_filter( p_dst, edge, h->mb.i_neighbour8[i], x264_pred_i4x4_neighbors[i_mode] );
  669.             if( h->mb.b_lossless )
  670.                 x264_predict_lossless_8x8( h, p_dst, i, i_mode, edge );
  671.             else
  672.                 h->predict_8x8[i_mode]( p_dst, edge );
  674.             x264_mb_encode_i8x8( h, i, i_qp );
  675.         }
  676.     }
  677.     else if( h->mb.i_type == I_4x4 )
  678.     {
  679.         h->mb.b_transform_8x8 = 0;
  680.         /* If we already encoded 15 of the 16 i4x4 blocks, we don't have to do them again. */
  681.         if( h->mb.i_skip_intra )
  682.         {
  683.             h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i4x4_fdec_buf, 16, 16 );
  684.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]] = h->mb.pic.i4x4_nnz_buf[0];
  685.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]] = h->mb.pic.i4x4_nnz_buf[1];
  686.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]] = h->mb.pic.i4x4_nnz_buf[2];
  687.             *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]] = h->mb.pic.i4x4_nnz_buf[3];
  688.             h->mb.i_cbp_luma = h->mb.pic.i4x4_cbp;
  689.             /* In RD mode, restore the now-overwritten DCT data. */
  690.             if( h->mb.i_skip_intra == 2 )
  691.                 h->mc.memcpy_aligned( h->dct.luma4x4, h->mb.pic.i4x4_dct_buf, sizeof(h->mb.pic.i4x4_dct_buf) );
  692.         }
  693.         for( i = h->mb.i_skip_intra ? 15 : 0 ; i < 16; i++ )
  694.         {
  695.             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][block_idx_xy_fdec[i]];
  696.             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
  698.             if( (h->mb.i_neighbour4[i] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
  699.                 /* emulate missing topright samples */
  700.                 *(uint32_t*) &p_dst[4-FDEC_STRIDE] = p_dst[3-FDEC_STRIDE] * 0x01010101U;
  702.             if( h->mb.b_lossless )
  703.                 x264_predict_lossless_4x4( h, p_dst, i, i_mode );
  704.             else
  705.                 h->predict_4x4[i_mode]( p_dst );
  706.             x264_mb_encode_i4x4( h, i, i_qp );
  707.         }
  708.     }
  709.     else    /* Inter MB */
  710.     {
  711.         int i8x8, i4x4;
  712.         int i_decimate_mb = 0;
  714.         /* Don't repeat motion compensation if it was already done in non-RD transform analysis */
  715.         if( !h->mb.b_skip_mc )
  716.             x264_mb_mc( h );
  718.         if( h->mb.b_lossless )
  719.         {
  720.             if( h->mb.b_transform_8x8 )
  721.                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
  722.                 {
  723.                     int x = 8*(i8x8&1);
  724.                     int y = 8*(i8x8>>1);
  725.                     nz = h->zigzagf.sub_8x8( h->dct.luma8x8[i8x8],
  726.                                         h->mb.pic.p_fenc[0]+x+y*FENC_STRIDE,
  727.                                         h->mb.pic.p_fdec[0]+x+y*FDEC_STRIDE );
  728.                     STORE_8x8_NNZ(i8x8,nz);
  729.                     h->mb.i_cbp_luma |= nz << i8x8;
  730.                 }
  731.             else
  732.                 for( i4x4 = 0; i4x4 < 16; i4x4++ )
  733.                 {
  734.                     nz = h->zigzagf.sub_4x4( h->dct.luma4x4[i4x4],
  735.                                         h->mb.pic.p_fenc[0]+block_idx_xy_fenc[i4x4],
  736.                                         h->mb.pic.p_fdec[0]+block_idx_xy_fdec[i4x4] );
  737.                     h->mb.cache.non_zero_count[x264_scan8[i4x4]] = nz;
  738.                     h->mb.i_cbp_luma |= nz << (i4x4>>2);
  739.                 }
  740.         }
  741.         else if( h->mb.b_transform_8x8 )
  742.         {
  743.             ALIGNED_ARRAY_16( int16_t, dct8x8,[4],[8][8] );
  744.             b_decimate &= !h->mb.b_trellis; // 8x8 trellis is inherently optimal decimation
  745.             h->dctf.sub16x16_dct8( dct8x8, h->mb.pic.p_fenc[0], h->mb.pic.p_fdec[0] );
  746.             h->nr_count[1] += h->mb.b_noise_reduction * 4;
  748.             for( idx = 0; idx < 4; idx++ )
  749.             {
  750.                 if( h->mb.b_noise_reduction )
  751.                     h->quantf.denoise_dct( *dct8x8[idx], h->nr_residual_sum[1], h->nr_offset[1], 64 );
  752.                 nz = x264_quant_8x8( h, dct8x8[idx], i_qp, 0, idx );
  754.                 if( nz )
  755.                 {
  756.                     h->zigzagf.scan_8x8( h->dct.luma8x8[idx], dct8x8[idx] );
  757.                     if( b_decimate )
  758.                     {
  759.                         int i_decimate_8x8 = h->quantf.decimate_score64( h->dct.luma8x8[idx] );
  760.                         i_decimate_mb += i_decimate_8x8;
  761.                         if( i_decimate_8x8 >= 4 )
  762.                             h->mb.i_cbp_luma |= 1<<idx;
  763.                     }
  764.                     else
  765.                         h->mb.i_cbp_luma |= 1<<idx;
  766.                 }
  767.             }
  769.             if( i_decimate_mb < 6 && b_decimate )
  770.             {
  771.                 h->mb.i_cbp_luma = 0;
  772.                 *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]] = 0;
  773.                 *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]] = 0;
  774.                 *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]] = 0;
  775.                 *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]] = 0;
  776.             }
  777.             else
  778.             {
  779.                 for( idx = 0; idx < 4; idx++ )
  780.                 {
  781.                     if( h->mb.i_cbp_luma&(1<<idx) )
  782.                     {
  783.                         h->quantf.dequant_8x8( dct8x8[idx], h->dequant8_mf[CQM_8PY], i_qp );
  784.                         h->dctf.add8x8_idct8( &h->mb.pic.p_fdec[0][(idx&1)*8 + (idx>>1)*8*FDEC_STRIDE], dct8x8[idx] );
  785.                         STORE_8x8_NNZ(idx,1);
  786.                     }
  787.                     else
  788.                         STORE_8x8_NNZ(idx,0);
  789.                 }
  790.             }
  791.         }
  792.         else
  793.         {
  794.             ALIGNED_ARRAY_16( int16_t, dct4x4,[16],[4][4] );
  795.             h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], h->mb.pic.p_fdec[0] );
  796.             h->nr_count[0] += h->mb.b_noise_reduction * 16;
  798.             for( i8x8 = 0; i8x8 < 4; i8x8++ )
  799.             {
  800.                 int i_decimate_8x8 = 0;
  801.                 int cbp = 0;
  803.                 /* encode one 4x4 block */
  804.                 for( i4x4 = 0; i4x4 < 4; i4x4++ )
  805.                 {
  806.                     idx = i8x8 * 4 + i4x4;
  808.                     if( h->mb.b_noise_reduction )
  809.                         h->quantf.denoise_dct( *dct4x4[idx], h->nr_residual_sum[0], h->nr_offset[0], 16 );
  810.                     nz = x264_quant_4x4( h, dct4x4[idx], i_qp, DCT_LUMA_4x4, 0, idx );
  811.                     h->mb.cache.non_zero_count[x264_scan8[idx]] = nz;
  813.                     if( nz )
  814.                     {
  815.                         h->zigzagf.scan_4x4( h->dct.luma4x4[idx], dct4x4[idx] );
  816.                         h->quantf.dequant_4x4( dct4x4[idx], h->dequant4_mf[CQM_4PY], i_qp );
  817.                         if( b_decimate && i_decimate_8x8 < 6 )
  818.                             i_decimate_8x8 += h->quantf.decimate_score16( h->dct.luma4x4[idx] );
  819.                         cbp = 1;
  820.                     }
  821.                 }
  823.                 /* decimate this 8x8 block */
  824.                 i_decimate_mb += i_decimate_8x8;
  825.                 if( b_decimate )
  826.                 {
  827.                     if( i_decimate_8x8 < 4 )
  828.                         STORE_8x8_NNZ(i8x8,0)
  829.                     else
  830.                         h->mb.i_cbp_luma |= 1<<i8x8;
  831.                 }
  832.                 else if( cbp )
  833.                 {
  834.                     h->dctf.add8x8_idct( &h->mb.pic.p_fdec[0][(i8x8&1)*8 + (i8x8>>1)*8*FDEC_STRIDE], &dct4x4[i8x8*4] );
  835.                     h->mb.i_cbp_luma |= 1<<i8x8;
  836.                 }
  837.             }
  839.             if( b_decimate )
  840.             {
  841.                 if( i_decimate_mb < 6 )
  842.                 {
  843.                     h->mb.i_cbp_luma = 0;
  844.                     *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]] = 0;
  845.                     *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]] = 0;
  846.                     *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]] = 0;
  847.                     *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]] = 0;
  848.                 }
  849.                 else
  850.                 {
  851.                     for( i8x8 = 0; i8x8 < 4; i8x8++ )
  852.                         if( h->mb.i_cbp_luma&(1<<i8x8) )
  853.                             h->dctf.add8x8_idct( &h->mb.pic.p_fdec[0][(i8x8&1)*8 + (i8x8>>1)*8*FDEC_STRIDE], &dct4x4[i8x8*4] );
  854.                 }
  855.             }
  856.         }
  857.     }
  859.     /* encode chroma */
  860.     if( IS_INTRA( h->mb.i_type ) )
  861.     {
  862.         const int i_mode = h->mb.i_chroma_pred_mode;
  863.         if( h->mb.b_lossless )
  864.             x264_predict_lossless_8x8_chroma( h, i_mode );
  865.         else
  866.         {
  867.             h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
  868.             h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
  869.         }
  870.     }
  872.     /* encode the 8x8 blocks */
  873.     x264_mb_encode_8x8_chroma( h, !IS_INTRA( h->mb.i_type ), h->mb.i_chroma_qp );
  875.     if( h->param.b_cabac )
  876.     {
  877.         i_cbp_dc = h->mb.cache.non_zero_count[x264_scan8[24]]
  878.                  | h->mb.cache.non_zero_count[x264_scan8[25]] << 1
  879.                  | h->mb.cache.non_zero_count[x264_scan8[26]] << 2;
  880.     }
  882.     /* store cbp */
  883.     h->mb.cbp[h->mb.i_mb_xy] = (i_cbp_dc << 8) | (h->mb.i_cbp_chroma << 4) | h->mb.i_cbp_luma;
  885.     /* Check for P_SKIP
  886.      * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
  887.      *      (if multiple mv give same result)*/
  888.     if( !b_force_no_skip )
  889.     {
  890.         if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
  891.             !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) &&
  892.             *(uint32_t*)h->mb.cache.mv[0][x264_scan8[0]] == *(uint32_t*)h->mb.cache.pskip_mv
  893.             && h->mb.cache.ref[0][x264_scan8[0]] == 0 )
  894.         {
  895.             h->mb.i_type = P_SKIP;
  896.         }
  898.         /* Check for B_SKIP */
  899.         if( h->mb.i_type == B_DIRECT && !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) )
  900.         {
  901.             h->mb.i_type = B_SKIP;
  902.         }
  903.     }
  904. }
  906. /*****************************************************************************
  907.  * x264_macroblock_probe_skip:
  908.  *  Check if the current MB could be encoded as a [PB]_SKIP (it supposes you use
  909.  *  the previous QP
  910.  *****************************************************************************/
  911. int x264_macroblock_probe_skip( x264_t *h, int b_bidir )
  912. {
  913.     ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4][4] );
  914.     ALIGNED_ARRAY_16( int16_t, dct2x2,[2],[2] );
  915.     ALIGNED_ARRAY_16( int16_t, dctscan,[16] );
  917.     int i_qp = h->mb.i_qp;
  918.     int mvp[2];
  919.     int ch, thresh, ssd;
  921.     int i8x8, i4x4;
  922.     int i_decimate_mb;
  924.     if( !b_bidir )
  925.     {
  926.         /* Get the MV */
  927.         mvp[0] = x264_clip3( h->mb.cache.pskip_mv[0], h->mb.mv_min[0], h->mb.mv_max[0] );
  928.         mvp[1] = x264_clip3( h->mb.cache.pskip_mv[1], h->mb.mv_min[1], h->mb.mv_max[1] );
  930.         /* Motion compensation */
  931.         h->mc.mc_luma( h->mb.pic.p_fdec[0],    FDEC_STRIDE,
  932.                        h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
  933.                        mvp[0], mvp[1], 16, 16 );
  934.     }
  936.     for( i8x8 = 0, i_decimate_mb = 0; i8x8 < 4; i8x8++ )
  937.     {
  938.         int fenc_offset = (i8x8&1) * 8 + (i8x8>>1) * FENC_STRIDE * 8;
  939.         int fdec_offset = (i8x8&1) * 8 + (i8x8>>1) * FDEC_STRIDE * 8;
  940.         /* get luma diff */
  941.         h->dctf.sub8x8_dct( dct4x4, h->mb.pic.p_fenc[0] + fenc_offset,
  942.                                     h->mb.pic.p_fdec[0] + fdec_offset );
  943.         /* encode one 4x4 block */
  944.         for( i4x4 = 0; i4x4 < 4; i4x4++ )
  945.         {
  946.             if( !h->quantf.quant_4x4( dct4x4[i4x4], h->quant4_mf[CQM_4PY][i_qp], h->quant4_bias[CQM_4PY][i_qp] ) )
  947.                 continue;
  948.             h->zigzagf.scan_4x4( dctscan, dct4x4[i4x4] );
  949.             i_decimate_mb += h->quantf.decimate_score16( dctscan );
  950.             if( i_decimate_mb >= 6 )
  951.                 return 0;
  952.         }
  953.     }
  955.     /* encode chroma */
  956.     i_qp = h->mb.i_chroma_qp;
  957.     thresh = (x264_lambda2_tab[i_qp] + 32) >> 6;
  959.     for( ch = 0; ch < 2; ch++ )
  960.     {
  961.         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
  962.         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
  964.         if( !b_bidir )
  965.         {
  966.             h->mc.mc_chroma( h->mb.pic.p_fdec[1+ch],       FDEC_STRIDE,
  967.                              h->mb.pic.p_fref[0][0][4+ch], h->mb.pic.i_stride[1+ch],
  968.                              mvp[0], mvp[1], 8, 8 );
  969.         }
  971.         /* there is almost never a termination during chroma, but we can't avoid the check entirely */
  972.         /* so instead we check SSD and skip the actual check if the score is low enough. */
  973.         ssd = h->pixf.ssd[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE );
  974.         if( ssd < thresh )
  975.             continue;
  977.         h->dctf.sub8x8_dct( dct4x4, p_src, p_dst );
  979.         /* calculate dct DC */
  980.         dct2x2dc( dct2x2, dct4x4 );
  981.         if( h->quantf.quant_2x2_dc( dct2x2, h->quant4_mf[CQM_4PC][i_qp][0]>>1, h->quant4_bias[CQM_4PC][i_qp][0]<<1 ) )
  982.             return 0;
  984.         /* If there wasn't a termination in DC, we can check against a much higher threshold. */
  985.         if( ssd < thresh*4 )
  986.             continue;
  988.         /* calculate dct coeffs */
  989.         for( i4x4 = 0, i_decimate_mb = 0; i4x4 < 4; i4x4++ )
  990.         {
  991.             if( !h->quantf.quant_4x4( dct4x4[i4x4], h->quant4_mf[CQM_4PC][i_qp], h->quant4_bias[CQM_4PC][i_qp] ) )
  992.                 continue;
  993.             h->zigzagf.scan_4x4( dctscan, dct4x4[i4x4] );
  994.             i_decimate_mb += h->quantf.decimate_score15( dctscan );
  995.             if( i_decimate_mb >= 7 )
  996.                 return 0;
  997.         }
  998.     }
  1000.     h->mb.b_skip_mc = 1;
  1001.     return 1;
  1002. }
  1004. /****************************************************************************
  1005.  * DCT-domain noise reduction / adaptive deadzone
  1006.  * from libavcodec
  1007.  ****************************************************************************/
  1009. void x264_noise_reduction_update( x264_t *h )
  1010. {
  1011.     int cat, i;
  1012.     for( cat = 0; cat < 2; cat++ )
  1013.     {
  1014.         int size = cat ? 64 : 16;
  1015.         const uint16_t *weight = cat ? x264_dct8_weight2_tab : x264_dct4_weight2_tab;
  1017.         if( h->nr_count[cat] > (cat ? (1<<16) : (1<<18)) )
  1018.         {
  1019.             for( i = 0; i < size; i++ )
  1020.                 h->nr_residual_sum[cat][i] >>= 1;
  1021.             h->nr_count[cat] >>= 1;
  1022.         }
  1024.         for( i = 0; i < size; i++ )
  1025.             h->nr_offset[cat][i] =
  1026.                 ((uint64_t)h->param.analyse.i_noise_reduction * h->nr_count[cat]
  1027.                  + h->nr_residual_sum[cat][i]/2)
  1028.               / ((uint64_t)h->nr_residual_sum[cat][i] * weight[i]/256 + 1);
  1029.     }
  1030. }
  1032. /*****************************************************************************
  1033.  * RD only; 4 calls to this do not make up for one macroblock_encode.
  1034.  * doesn't transform chroma dc.
  1035.  *****************************************************************************/
  1036. void x264_macroblock_encode_p8x8( x264_t *h, int i8 )
  1037. {
  1038.     int i_qp = h->mb.i_qp;
  1039.     uint8_t *p_fenc = h->mb.pic.p_fenc[0] + (i8&1)*8 + (i8>>1)*8*FENC_STRIDE;
  1040.     uint8_t *p_fdec = h->mb.pic.p_fdec[0] + (i8&1)*8 + (i8>>1)*8*FDEC_STRIDE;
  1041.     int b_decimate = h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate;
  1042.     int nnz8x8 = 0;
  1043.     int ch, nz;
  1045.     if( !h->mb.b_skip_mc )
  1046.         x264_mb_mc_8x8( h, i8 );
  1048.     if( h->mb.b_lossless )
  1049.     {
  1050.         int i4;
  1051.         if( h->mb.b_transform_8x8 )
  1052.         {
  1053.             nnz8x8 = h->zigzagf.sub_8x8( h->dct.luma8x8[i8], p_fenc, p_fdec );
  1054.             STORE_8x8_NNZ(i8,nnz8x8);
  1055.         }
  1056.         else
  1057.         {
  1058.             for( i4 = i8*4; i4 < i8*4+4; i4++ )
  1059.             {
  1060.                 int nz;
  1061.                 nz = h->zigzagf.sub_4x4( h->dct.luma4x4[i4],
  1062.                                     h->mb.pic.p_fenc[0]+block_idx_xy_fenc[i4],
  1063.                                     h->mb.pic.p_fdec[0]+block_idx_xy_fdec[i4] );
  1064.                 h->mb.cache.non_zero_count[x264_scan8[i4]] = nz;
  1065.                 nnz8x8 |= nz;
  1066.             }
  1067.         }
  1068.         for( ch = 0; ch < 2; ch++ )
  1069.         {
  1070.             int16_t dc;
  1071.             p_fenc = h->mb.pic.p_fenc[1+ch] + (i8&1)*4 + (i8>>1)*4*FENC_STRIDE;
  1072.             p_fdec = h->mb.pic.p_fdec[1+ch] + (i8&1)*4 + (i8>>1)*4*FDEC_STRIDE;
  1073.             nz = h->zigzagf.sub_4x4ac( h->dct.luma4x4[16+i8+ch*4], p_fenc, p_fdec, &dc );
  1074.             h->mb.cache.non_zero_count[x264_scan8[16+i8+ch*4]] = nz;
  1075.         }
  1076.     }
  1077.     else
  1078.     {
  1079.         if( h->mb.b_transform_8x8 )
  1080.         {
  1081.             ALIGNED_ARRAY_16( int16_t, dct8x8,[8],[8] );
  1082.             h->dctf.sub8x8_dct8( dct8x8, p_fenc, p_fdec );
  1083.             nnz8x8 = x264_quant_8x8( h, dct8x8, i_qp, 0, i8 );
  1084.             if( nnz8x8 )
  1085.             {
  1086.                 h->zigzagf.scan_8x8( h->dct.luma8x8[i8], dct8x8 );
  1088.                 if( b_decimate && !h->mb.b_trellis )
  1089.                     nnz8x8 = 4 <= h->quantf.decimate_score64( h->dct.luma8x8[i8] );
  1091.                 if( nnz8x8 )
  1092.                 {
  1093.                     h->quantf.dequant_8x8( dct8x8, h->dequant8_mf[CQM_8PY], i_qp );
  1094.                     h->dctf.add8x8_idct8( p_fdec, dct8x8 );
  1095.                     STORE_8x8_NNZ(i8,1);
  1096.                 }
  1097.                 else
  1098.                     STORE_8x8_NNZ(i8,0);
  1099.             }
  1100.             else
  1101.                 STORE_8x8_NNZ(i8,0);
  1102.         }
  1103.         else
  1104.         {
  1105.             int i4;
  1106.             int i_decimate_8x8 = 0;
  1107.             ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4][4] );
  1108.             h->dctf.sub8x8_dct( dct4x4, p_fenc, p_fdec );
  1109.             for( i4 = 0; i4 < 4; i4++ )
  1110.             {
  1111.                 nz = x264_quant_4x4( h, dct4x4[i4], i_qp, DCT_LUMA_4x4, 0, i8*4+i4 );
  1112.                 h->mb.cache.non_zero_count[x264_scan8[i8*4+i4]] = nz;
  1113.                 if( nz )
  1114.                 {
  1115.                     h->zigzagf.scan_4x4( h->dct.luma4x4[i8*4+i4], dct4x4[i4] );
  1116.                     h->quantf.dequant_4x4( dct4x4[i4], h->dequant4_mf[CQM_4PY], i_qp );
  1117.                     if( b_decimate )
  1118.                         i_decimate_8x8 += h->quantf.decimate_score16( h->dct.luma4x4[i8*4+i4] );
  1119.                     nnz8x8 = 1;
  1120.                 }
  1121.             }
  1123.             if( b_decimate && i_decimate_8x8 < 4 )
  1124.                 nnz8x8 = 0;
  1126.             if( nnz8x8 )
  1127.                 h->dctf.add8x8_idct( p_fdec, dct4x4 );
  1128.             else
  1129.                 STORE_8x8_NNZ(i8,0);
  1130.         }
  1132.         i_qp = h->mb.i_chroma_qp;
  1134.         for( ch = 0; ch < 2; ch++ )
  1135.         {
  1136.             ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4] );
  1137.             p_fenc = h->mb.pic.p_fenc[1+ch] + (i8&1)*4 + (i8>>1)*4*FENC_STRIDE;
  1138.             p_fdec = h->mb.pic.p_fdec[1+ch] + (i8&1)*4 + (i8>>1)*4*FDEC_STRIDE;
  1140.             h->dctf.sub4x4_dct( dct4x4, p_fenc, p_fdec );
  1141.             dct4x4[0][0] = 0;
  1143.             if( h->mb.b_trellis )
  1144.                 nz = x264_quant_4x4_trellis( h, dct4x4, CQM_4PC, i_qp, DCT_CHROMA_AC, 0, 1, 0 );
  1145.             else
  1146.                 nz = h->quantf.quant_4x4( dct4x4, h->quant4_mf[CQM_4PC][i_qp], h->quant4_bias[CQM_4PC][i_qp] );
  1148.             h->mb.cache.non_zero_count[x264_scan8[16+i8+ch*4]] = nz;
  1149.             if( nz )
  1150.             {
  1151.                 h->zigzagf.scan_4x4( h->dct.luma4x4[16+i8+ch*4], dct4x4 );
  1152.                 h->quantf.dequant_4x4( dct4x4, h->dequant4_mf[CQM_4PC], i_qp );
  1153.                 h->dctf.add4x4_idct( p_fdec, dct4x4 );
  1154.             }
  1155.         }
  1156.     }
  1157.     h->mb.i_cbp_luma &= ~(1 << i8);
  1158.     h->mb.i_cbp_luma |= nnz8x8 << i8;
  1159.     h->mb.i_cbp_chroma = 0x02;
  1160. }
  1162. /*****************************************************************************
  1163.  * RD only, luma only
  1164.  *****************************************************************************/
  1165. void x264_macroblock_encode_p4x4( x264_t *h, int i4 )
  1166. {
  1167.     int i_qp = h->mb.i_qp;
  1168.     uint8_t *p_fenc = &h->mb.pic.p_fenc[0][block_idx_xy_fenc[i4]];
  1169.     uint8_t *p_fdec = &h->mb.pic.p_fdec[0][block_idx_xy_fdec[i4]];
  1170.     const int i_ref = h->mb.cache.ref[0][x264_scan8[i4]];
  1171.     const int mvx   = x264_clip3( h->mb.cache.mv[0][x264_scan8[i4]][0], h->mb.mv_min[0], h->mb.mv_max[0] );
  1172.     const int mvy   = x264_clip3( h->mb.cache.mv[0][x264_scan8[i4]][1], h->mb.mv_min[1], h->mb.mv_max[1] );
  1173.     int nz;
  1175.     h->mc.mc_luma( p_fdec, FDEC_STRIDE, h->mb.pic.p_fref[0][i_ref], h->mb.pic.i_stride[0], mvx + 4*4*block_idx_x[i4], mvy + 4*4*block_idx_y[i4], 4, 4 );
  1177.     if( h->mb.b_lossless )
  1178.     {
  1179.         nz = h->zigzagf.sub_4x4( h->dct.luma4x4[i4], p_fenc, p_fdec );
  1180.         h->mb.cache.non_zero_count[x264_scan8[i4]] = nz;
  1181.     }
  1182.     else
  1183.     {
  1184.         ALIGNED_ARRAY_16( int16_t, dct4x4,[4],[4] );
  1185.         h->dctf.sub4x4_dct( dct4x4, p_fenc, p_fdec );
  1186.         nz = x264_quant_4x4( h, dct4x4, i_qp, DCT_LUMA_4x4, 0, i4 );
  1187.         h->mb.cache.non_zero_count[x264_scan8[i4]] = nz;
  1188.         if( nz )
  1189.         {
  1190.             h->zigzagf.scan_4x4( h->dct.luma4x4[i4], dct4x4 );
  1191.             h->quantf.dequant_4x4( dct4x4, h->dequant4_mf[CQM_4PY], i_qp );
  1192.             h->dctf.add4x4_idct( p_fdec, dct4x4 );
  1193.         }
  1194.     }
  1195. }