macroblock.c 34.7 KB
Newer Older
Laurent Aimar's avatar
Laurent Aimar committed
1 2 3
/*****************************************************************************
 * macroblock.c: h264 encoder library
 *****************************************************************************
4
 * Copyright (C) 2003-2008 x264 project
Laurent Aimar's avatar
Laurent Aimar committed
5 6
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 8
 *          Loren Merritt <lorenm@u.washington.edu>
 *          Fiona Glaser <fiona@x264.com>
Laurent Aimar's avatar
Laurent Aimar committed
9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
Laurent Aimar's avatar
Laurent Aimar committed
23 24
 *****************************************************************************/

25
#include "common/common.h"
Laurent Aimar's avatar
Laurent Aimar committed
26 27
#include "macroblock.h"

28
#define ZIG(i,y,x) level[i] = dct[x][y];
29
static inline void zigzag_scan_2x2_dc( int16_t level[4], int16_t dct[2][2] )
Laurent Aimar's avatar
Laurent Aimar committed
30
{
31 32 33 34
    ZIG(0,0,0)
    ZIG(1,0,1)
    ZIG(2,1,0)
    ZIG(3,1,1)
Laurent Aimar's avatar
Laurent Aimar committed
35
}
36
#undef ZIG
Laurent Aimar's avatar
Laurent Aimar committed
37 38 39 40 41 42 43 44 45

/* (ref: JVT-B118)
 * x264_mb_decimate_score: given dct coeffs it returns a score to see if we could empty this dct coeffs
 * to 0 (low score means set it to null)
 * Used in inter macroblock (luma and chroma)
 *  luma: for a 8x8 block: if score < 4 -> null
 *        for the complete mb: if score < 6 -> null
 *  chroma: for the complete mb: if score < 7 -> null
 */
46
static int x264_mb_decimate_score( int16_t *dct, int i_max )
Laurent Aimar's avatar
Laurent Aimar committed
47
{
48 49 50 51 52 53 54 55 56
    static const int i_ds_table4[16] = {
        3,2,2,1,1,1,0,0,0,0,0,0,0,0,0,0 };
    static const int i_ds_table8[64] = {
        3,3,3,3,2,2,2,2,2,2,2,2,1,1,1,1,
        1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };

    const int *ds_table = (i_max == 64) ? i_ds_table8 : i_ds_table4;
Laurent Aimar's avatar
Laurent Aimar committed
57 58 59 60 61 62 63 64 65 66
    int i_score = 0;
    int idx = i_max - 1;

    while( idx >= 0 && dct[idx] == 0 )
        idx--;

    while( idx >= 0 )
    {
        int i_run;

67
        if( (unsigned)(dct[idx--] + 1) > 2 )
Laurent Aimar's avatar
Laurent Aimar committed
68 69 70 71 72 73 74 75
            return 9;

        i_run = 0;
        while( idx >= 0 && dct[idx] == 0 )
        {
            idx--;
            i_run++;
        }
76
        i_score += ds_table[i_run];
Laurent Aimar's avatar
Laurent Aimar committed
77 78 79 80 81
    }

    return i_score;
}

82
static ALWAYS_INLINE void x264_quant_4x4( x264_t *h, int16_t dct[4][4], int i_qp, int i_ctxBlockCat, int b_intra, int idx )
83 84 85
{
    int i_quant_cat = b_intra ? CQM_4IY : CQM_4PY;
    if( h->mb.b_trellis )
86
        x264_quant_4x4_trellis( h, dct, i_quant_cat, i_qp, i_ctxBlockCat, b_intra, idx );
87 88 89 90
    else
        h->quantf.quant_4x4( dct, h->quant4_mf[i_quant_cat][i_qp], h->quant4_bias[i_quant_cat][i_qp] );
}

91
static ALWAYS_INLINE void x264_quant_8x8( x264_t *h, int16_t dct[8][8], int i_qp, int b_intra, int idx )
92 93 94
{
    int i_quant_cat = b_intra ? CQM_8IY : CQM_8PY;
    if( h->mb.b_trellis )
95
        x264_quant_8x8_trellis( h, dct, i_quant_cat, i_qp, b_intra, idx );
96 97 98 99 100
    else
        h->quantf.quant_8x8( dct, h->quant8_mf[i_quant_cat][i_qp], h->quant8_bias[i_quant_cat][i_qp] );
}

void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qp )
Laurent Aimar's avatar
Laurent Aimar committed
101
{
102 103
    uint8_t *p_src = &h->mb.pic.p_fenc[0][block_idx_xy_fenc[idx]];
    uint8_t *p_dst = &h->mb.pic.p_fdec[0][block_idx_xy_fdec[idx]];
Loren Merritt's avatar
Loren Merritt committed
104
    DECLARE_ALIGNED_16( int16_t dct4x4[4][4] );
Laurent Aimar's avatar
Laurent Aimar committed
105

Loren Merritt's avatar
Loren Merritt committed
106 107
    if( h->mb.b_lossless )
    {
108
        h->zigzagf.sub_4x4( h->dct.luma4x4[idx], p_src, p_dst );
Loren Merritt's avatar
Loren Merritt committed
109 110 111
        return;
    }

112
    h->dctf.sub4x4_dct( dct4x4, p_src, p_dst );
Loren Merritt's avatar
Loren Merritt committed
113

114
    x264_quant_4x4( h, dct4x4, i_qp, DCT_LUMA_4x4, 1, idx );
Loren Merritt's avatar
Loren Merritt committed
115

116 117 118
    if( array_non_zero( dct4x4 ) )
    {
        h->zigzagf.scan_4x4( h->dct.luma4x4[idx], dct4x4 );
119
        h->quantf.dequant_4x4( dct4x4, h->dequant4_mf[CQM_4IY], i_qp );
Laurent Aimar's avatar
Laurent Aimar committed
120

121 122 123 124 125
        /* output samples to fdec */
        h->dctf.add4x4_idct( p_dst, dct4x4 );
    }
    else
        memset( h->dct.luma4x4[idx], 0, sizeof(h->dct.luma4x4[idx]));
Laurent Aimar's avatar
Laurent Aimar committed
126 127
}

128
void x264_mb_encode_i8x8( x264_t *h, int idx, int i_qp )
129
{
130 131 132 133
    int x = 8 * (idx&1);
    int y = 8 * (idx>>1);
    uint8_t *p_src = &h->mb.pic.p_fenc[0][x+y*FENC_STRIDE];
    uint8_t *p_dst = &h->mb.pic.p_fdec[0][x+y*FDEC_STRIDE];
Loren Merritt's avatar
Loren Merritt committed
134
    DECLARE_ALIGNED_16( int16_t dct8x8[8][8] );
135

136 137 138 139 140 141
    if( h->mb.b_lossless )
    {
        h->zigzagf.sub_8x8( h->dct.luma8x8[idx], p_src, p_dst );
        return;
    }

142
    h->dctf.sub8x8_dct8( dct8x8, p_src, p_dst );
Loren Merritt's avatar
Loren Merritt committed
143

144
    x264_quant_8x8( h, dct8x8, i_qp, 1, idx );
Loren Merritt's avatar
Loren Merritt committed
145

146
    h->zigzagf.scan_8x8( h->dct.luma8x8[idx], dct8x8 );
147
    h->quantf.dequant_8x8( dct8x8, h->dequant8_mf[CQM_8IY], i_qp );
148
    h->dctf.add8x8_idct8( p_dst, dct8x8 );
149 150
}

151
static void x264_mb_encode_i16x16( x264_t *h, int i_qp )
Laurent Aimar's avatar
Laurent Aimar committed
152 153 154 155
{
    uint8_t  *p_src = h->mb.pic.p_fenc[0];
    uint8_t  *p_dst = h->mb.pic.p_fdec[0];

156 157
    DECLARE_ALIGNED_16( int16_t dct4x4[16][4][4] );
    DECLARE_ALIGNED_16( int16_t dct_dc4x4[4][4] );
Laurent Aimar's avatar
Laurent Aimar committed
158 159 160

    int i;

Loren Merritt's avatar
Loren Merritt committed
161 162 163 164
    if( h->mb.b_lossless )
    {
        for( i = 0; i < 16; i++ )
        {
165 166
            int oe = block_idx_xy_fenc[i];
            int od = block_idx_xy_fdec[i];
167
            h->zigzagf.sub_4x4( h->dct.luma4x4[i], p_src+oe, p_dst+od );
168
            dct_dc4x4[0][block_idx_yx_1d[i]] = h->dct.luma4x4[i][0];
Fiona Glaser's avatar
Fiona Glaser committed
169
            h->dct.luma4x4[i][0] = 0;
Loren Merritt's avatar
Loren Merritt committed
170
        }
171
        h->zigzagf.scan_4x4( h->dct.luma16x16_dc, dct_dc4x4 );
Loren Merritt's avatar
Loren Merritt committed
172 173 174
        return;
    }

175
    h->dctf.sub16x16_dct( dct4x4, p_src, p_dst );
Laurent Aimar's avatar
Laurent Aimar committed
176 177 178
    for( i = 0; i < 16; i++ )
    {
        /* copy dc coeff */
179
        dct_dc4x4[0][block_idx_xy_1d[i]] = dct4x4[i][0][0];
180
        dct4x4[i][0][0] = 0;
Laurent Aimar's avatar
Laurent Aimar committed
181 182

        /* quant/scan/dequant */
183
        x264_quant_4x4( h, dct4x4[i], i_qp, DCT_LUMA_AC, 1, i );
Loren Merritt's avatar
Loren Merritt committed
184

185
        h->zigzagf.scan_4x4( h->dct.luma4x4[i], dct4x4[i] );
186
        h->quantf.dequant_4x4( dct4x4[i], h->dequant4_mf[CQM_4IY], i_qp );
Laurent Aimar's avatar
Laurent Aimar committed
187 188
    }

189
    h->dctf.dct4x4dc( dct_dc4x4 );
190 191 192 193
    if( h->mb.b_trellis )
        x264_quant_dc_trellis( h, (int16_t*)dct_dc4x4, CQM_4IY, i_qp, DCT_LUMA_DC, 1);
    else
        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 );
194
    h->zigzagf.scan_4x4( h->dct.luma16x16_dc, dct_dc4x4 );
Laurent Aimar's avatar
Laurent Aimar committed
195 196

    /* output samples to fdec */
197
    h->dctf.idct4x4dc( dct_dc4x4 );
198
    x264_mb_dequant_4x4_dc( dct_dc4x4, h->dequant4_mf[CQM_4IY], i_qp );  /* XXX not inversed */
Laurent Aimar's avatar
Laurent Aimar committed
199 200 201 202 203

    /* calculate dct coeffs */
    for( i = 0; i < 16; i++ )
    {
        /* copy dc coeff */
204
        dct4x4[i][0][0] = dct_dc4x4[0][block_idx_xy_1d[i]];
Laurent Aimar's avatar
Laurent Aimar committed
205 206
    }
    /* put pixels to fdec */
207
    h->dctf.add16x16_idct( p_dst, dct4x4 );
Laurent Aimar's avatar
Laurent Aimar committed
208 209
}

210
void x264_mb_encode_8x8_chroma( x264_t *h, int b_inter, int i_qp )
Laurent Aimar's avatar
Laurent Aimar committed
211 212
{
    int i, ch;
213
    int b_decimate = b_inter && (h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate);
Laurent Aimar's avatar
Laurent Aimar committed
214 215 216 217 218 219 220

    for( ch = 0; ch < 2; ch++ )
    {
        uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
        uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
        int i_decimate_score = 0;

Loren Merritt's avatar
Loren Merritt committed
221 222
        DECLARE_ALIGNED_16( int16_t dct2x2[2][2]  );
        DECLARE_ALIGNED_16( int16_t dct4x4[4][4][4] );
Laurent Aimar's avatar
Laurent Aimar committed
223

Loren Merritt's avatar
Loren Merritt committed
224 225 226 227
        if( h->mb.b_lossless )
        {
            for( i = 0; i < 4; i++ )
            {
228 229
                int oe = block_idx_x[i]*4 + block_idx_y[i]*4*FENC_STRIDE;
                int od = block_idx_x[i]*4 + block_idx_y[i]*4*FDEC_STRIDE;
230
                h->zigzagf.sub_4x4( h->dct.luma4x4[16+i+ch*4], p_src+oe, p_dst+od );
Loren Merritt's avatar
Loren Merritt committed
231
                h->dct.chroma_dc[ch][i] = h->dct.luma4x4[16+i+ch*4][0];
Fiona Glaser's avatar
Fiona Glaser committed
232
                h->dct.luma4x4[16+i+ch*4][0] = 0;
Loren Merritt's avatar
Loren Merritt committed
233 234 235
            }
            continue;
        }
Loren Merritt's avatar
Loren Merritt committed
236

237
        h->dctf.sub8x8_dct( dct4x4, p_src, p_dst );
Laurent Aimar's avatar
Laurent Aimar committed
238 239 240 241
        /* calculate dct coeffs */
        for( i = 0; i < 4; i++ )
        {
            /* copy dc coeff */
242
            dct2x2[i>>1][i&1] = dct4x4[i][0][0];
243
            dct4x4[i][0][0] = 0;
Laurent Aimar's avatar
Laurent Aimar committed
244

245 246 247 248
            if( h->mb.b_trellis )
                x264_quant_4x4_trellis( h, dct4x4[i], CQM_4IC+b_inter, i_qp, DCT_CHROMA_AC, !b_inter, 0 );
            else
                h->quantf.quant_4x4( dct4x4[i], h->quant4_mf[CQM_4IC+b_inter][i_qp], h->quant4_bias[CQM_4IC+b_inter][i_qp] );
249
            h->zigzagf.scan_4x4( h->dct.luma4x4[16+i+ch*4], dct4x4[i] );
Laurent Aimar's avatar
Laurent Aimar committed
250

251
            if( b_decimate )
252
                i_decimate_score += x264_mb_decimate_score( h->dct.luma4x4[16+i+ch*4]+1, 15 );
Laurent Aimar's avatar
Laurent Aimar committed
253 254 255
        }

        h->dctf.dct2x2dc( dct2x2 );
256 257 258 259
        if( h->mb.b_trellis )
            x264_quant_dc_trellis( h, (int16_t*)dct2x2, CQM_4IC+b_inter, i_qp, DCT_CHROMA_DC, !b_inter );
        else
            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 );
260
        zigzag_scan_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
Laurent Aimar's avatar
Laurent Aimar committed
261 262 263

        /* output samples to fdec */
        h->dctf.idct2x2dc( dct2x2 );
264
        x264_mb_dequant_2x2_dc( dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qp );  /* XXX not inversed */
Laurent Aimar's avatar
Laurent Aimar committed
265

266
        if( b_decimate && i_decimate_score < 7 )
Laurent Aimar's avatar
Laurent Aimar committed
267 268
        {
            /* Near null chroma 8x8 block so make it null (bits saving) */
269
            memset( &h->dct.luma4x4[16+ch*4], 0, 4 * sizeof( *h->dct.luma4x4 ) );
270
            if( !array_non_zero( dct2x2 ) )
271 272
                continue;
            memset( dct4x4, 0, sizeof( dct4x4 ) );
Laurent Aimar's avatar
Laurent Aimar committed
273
        }
274 275 276
        else
        {
            for( i = 0; i < 4; i++ )
277
                h->quantf.dequant_4x4( dct4x4[i], h->dequant4_mf[CQM_4IC + b_inter], i_qp );
278
        }
279 280 281 282
        dct4x4[0][0][0] = dct2x2[0][0];
        dct4x4[1][0][0] = dct2x2[0][1];
        dct4x4[2][0][0] = dct2x2[1][0];
        dct4x4[3][0][0] = dct2x2[1][1];
283
        h->dctf.add8x8_idct( p_dst, dct4x4 );
Laurent Aimar's avatar
Laurent Aimar committed
284
    }
285 286 287 288 289

    /* coded block pattern */
    h->mb.i_cbp_chroma = 0;
    for( i = 0; i < 8; i++ )
    {
290
        int nz = array_non_zero( h->dct.luma4x4[16+i] );
291 292 293 294 295
        h->mb.cache.non_zero_count[x264_scan8[16+i]] = nz;
        h->mb.i_cbp_chroma |= nz;
    }
    if( h->mb.i_cbp_chroma )
        h->mb.i_cbp_chroma = 2;    /* dc+ac (we can't do only ac) */
296
    else if( array_non_zero( h->dct.chroma_dc ) )
297
        h->mb.i_cbp_chroma = 1;    /* dc only */
Laurent Aimar's avatar
Laurent Aimar committed
298 299
}

300 301 302 303
static void x264_macroblock_encode_skip( x264_t *h )
{
    h->mb.i_cbp_luma = 0x00;
    h->mb.i_cbp_chroma = 0x00;
304
    memset( h->mb.cache.non_zero_count, 0, X264_SCAN8_SIZE );
305 306 307 308
    /* store cbp */
    h->mb.cbp[h->mb.i_mb_xy] = 0;
}

Laurent Aimar's avatar
Laurent Aimar committed
309 310 311 312
/*****************************************************************************
 * x264_macroblock_encode_pskip:
 *  Encode an already marked skip block
 *****************************************************************************/
Loic Le Loarer's avatar
Loic Le Loarer committed
313
static void x264_macroblock_encode_pskip( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
314
{
315 316 317 318
    const int mvx = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][0],
                                h->mb.mv_min[0], h->mb.mv_max[0] );
    const int mvy = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][1],
                                h->mb.mv_min[1], h->mb.mv_max[1] );
Laurent Aimar's avatar
Laurent Aimar committed
319

320
    /* don't do pskip motion compensation if it was already done in macroblock_analyse */
321
    if( !h->mb.b_skip_mc )
322 323 324 325
    {
        h->mc.mc_luma( h->mb.pic.p_fdec[0],    FDEC_STRIDE,
                       h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
                       mvx, mvy, 16, 16 );
Laurent Aimar's avatar
Laurent Aimar committed
326

327 328 329
        h->mc.mc_chroma( h->mb.pic.p_fdec[1],       FDEC_STRIDE,
                         h->mb.pic.p_fref[0][0][4], h->mb.pic.i_stride[1],
                         mvx, mvy, 8, 8 );
Laurent Aimar's avatar
Laurent Aimar committed
330

331 332 333 334
        h->mc.mc_chroma( h->mb.pic.p_fdec[2],       FDEC_STRIDE,
                         h->mb.pic.p_fref[0][0][5], h->mb.pic.i_stride[2],
                         mvx, mvy, 8, 8 );
    }
Laurent Aimar's avatar
Laurent Aimar committed
335

336
    x264_macroblock_encode_skip( h );
Laurent Aimar's avatar
Laurent Aimar committed
337 338
}

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
/*****************************************************************************
 * Intra prediction for predictive lossless mode.
 *****************************************************************************/

/* Note that these functions take a shortcut (mc.copy instead of actual pixel prediction) which assumes
 * that the edge pixels of the reconstructed frame are the same as that of the source frame.  This means
 * they will only work correctly if the neighboring blocks are losslessly coded.  In practice, this means
 * lossless mode cannot be mixed with lossy mode within a frame. */
/* This can be resolved by explicitly copying the edge pixels after doing the mc.copy, but this doesn't
 * need to be done unless we decide to allow mixing lossless and lossy compression. */

void x264_predict_lossless_8x8_chroma( x264_t *h, int i_mode )
{
    int stride = h->fenc->i_stride[1] << h->mb.b_interlaced;
    if( i_mode == I_PRED_CHROMA_V )
    {
        h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc_plane[1]-stride, stride, 8 );
        h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc_plane[2]-stride, stride, 8 );
    }
    else if( i_mode == I_PRED_CHROMA_H )
    {
        h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc_plane[1]-1, stride, 8 );
        h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc_plane[2]-1, stride, 8 );
    }
    else
    {
        h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
        h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
    }
}

void x264_predict_lossless_4x4( x264_t *h, uint8_t *p_dst, int idx, int i_mode )
{
    int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
    uint8_t *p_src = h->mb.pic.p_fenc_plane[0] + block_idx_x[idx]*4 + block_idx_y[idx]*4 * stride;

    if( i_mode == I_PRED_4x4_V )
        h->mc.copy[PIXEL_4x4]( p_dst, FDEC_STRIDE, p_src-stride, stride, 4 );
    else if( i_mode == I_PRED_4x4_H )
        h->mc.copy[PIXEL_4x4]( p_dst, FDEC_STRIDE, p_src-1, stride, 4 );
    else
        h->predict_4x4[i_mode]( p_dst );
}

void x264_predict_lossless_8x8( x264_t *h, uint8_t *p_dst, int idx, int i_mode, uint8_t edge[33] )
{
    int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
    uint8_t *p_src = h->mb.pic.p_fenc_plane[0] + (idx&1)*8 + (idx>>1)*8*stride;

    if( i_mode == I_PRED_8x8_V )
        h->mc.copy[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src-stride, stride, 8 );
    else if( i_mode == I_PRED_8x8_H )
        h->mc.copy[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src-1, stride, 8 );
    else
        h->predict_8x8[i_mode]( p_dst, edge );
}

void x264_predict_lossless_16x16( x264_t *h, int i_mode )
{
    int stride = h->fenc->i_stride[0] << h->mb.b_interlaced;
    if( i_mode == I_PRED_16x16_V )
        h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc_plane[0]-stride, stride, 16 );
    else if( i_mode == I_PRED_16x16_H )
        h->mc.copy_16x16_unaligned( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc_plane[0]-1, stride, 16 );
    else
        h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0] );
}

Laurent Aimar's avatar
Laurent Aimar committed
407 408 409 410 411 412
/*****************************************************************************
 * x264_macroblock_encode:
 *****************************************************************************/
void x264_macroblock_encode( x264_t *h )
{
    int i_cbp_dc = 0;
413
    int i_qp = h->mb.i_qp;
414
    int b_decimate = h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate;
415
    int b_force_no_skip = 0;
416 417
    int i,j,idx;
    uint8_t nnz8x8[4] = {1,1,1,1};
Laurent Aimar's avatar
Laurent Aimar committed
418

419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
    if( h->sh.b_mbaff
        && h->mb.i_mb_xy == h->sh.i_first_mb + h->mb.i_mb_stride
        && IS_SKIP(h->mb.type[h->sh.i_first_mb]) )
    {
        /* The first skip is predicted to be a frame mb pair.
         * We don't yet support the aff part of mbaff, so force it to non-skip
         * so that we can pick the aff flag. */
        b_force_no_skip = 1;
        if( IS_SKIP(h->mb.i_type) )
        {
            if( h->mb.i_type == P_SKIP )
                h->mb.i_type = P_L0;
            else if( h->mb.i_type == B_SKIP )
                h->mb.i_type = B_DIRECT;
        }
    }

Laurent Aimar's avatar
Laurent Aimar committed
436 437 438 439 440 441
    if( h->mb.i_type == P_SKIP )
    {
        /* A bit special */
        x264_macroblock_encode_pskip( h );
        return;
    }
442 443
    if( h->mb.i_type == B_SKIP )
    {
444
        /* don't do bskip motion compensation if it was already done in macroblock_analyse */
445
        if( !h->mb.b_skip_mc )
446
            x264_mb_mc( h );
447 448 449
        x264_macroblock_encode_skip( h );
        return;
    }
Laurent Aimar's avatar
Laurent Aimar committed
450 451 452 453

    if( h->mb.i_type == I_16x16 )
    {
        const int i_mode = h->mb.i_intra16x16_pred_mode;
454
        h->mb.b_transform_8x8 = 0;
455 456 457 458 459

        if( h->mb.b_lossless )
            x264_predict_lossless_16x16( h, i_mode );
        else
            h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0] );
Laurent Aimar's avatar
Laurent Aimar committed
460 461

        /* encode the 16x16 macroblock */
462
        x264_mb_encode_i16x16( h, i_qp );
Laurent Aimar's avatar
Laurent Aimar committed
463
    }
464 465
    else if( h->mb.i_type == I_8x8 )
    {
Loren Merritt's avatar
Loren Merritt committed
466
        DECLARE_ALIGNED_16( uint8_t edge[33] );
467
        h->mb.b_transform_8x8 = 1;
468 469 470 471 472 473 474 475 476
        /* If we already encoded 3 of the 4 i8x8 blocks, we don't have to do them again. */
        if( h->mb.i_skip_intra )
        {
            h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i8x8_fdec_buf, 16, 16 );
            /* In RD mode, restore the now-overwritten DCT data. */
            if( h->mb.i_skip_intra == 2 )
                h->mc.memcpy_aligned( h->dct.luma8x8, h->mb.pic.i8x8_dct_buf, sizeof(h->mb.pic.i8x8_dct_buf) );
        }
        for( i = h->mb.i_skip_intra ? 3 : 0 ; i < 4; i++ )
477
        {
478
            uint8_t  *p_dst = &h->mb.pic.p_fdec[0][8 * (i&1) + 8 * (i>>1) * FDEC_STRIDE];
479
            int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]];
480
            x264_predict_8x8_filter( p_dst, edge, h->mb.i_neighbour8[i], x264_pred_i4x4_neighbors[i_mode] );
481 482 483 484 485 486

            if( h->mb.b_lossless )
                x264_predict_lossless_8x8( h, p_dst, i, i_mode, edge );
            else
                h->predict_8x8[i_mode]( p_dst, edge );

487
            x264_mb_encode_i8x8( h, i, i_qp );
488
        }
489 490
        for( i = 0; i < 4; i++ )
            nnz8x8[i] = array_non_zero( h->dct.luma8x8[i] );
491
    }
Laurent Aimar's avatar
Laurent Aimar committed
492 493
    else if( h->mb.i_type == I_4x4 )
    {
494
        h->mb.b_transform_8x8 = 0;
495 496 497 498 499 500
        /* If we already encoded 15 of the 16 i4x4 blocks, we don't have to do them again. */
        if( h->mb.i_skip_intra )
        {
            h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i4x4_fdec_buf, 16, 16 );
            /* In RD mode, restore the now-overwritten DCT data. */
            if( h->mb.i_skip_intra == 2 )
501
                h->mc.memcpy_aligned( h->dct.luma4x4, h->mb.pic.i4x4_dct_buf, sizeof(h->mb.pic.i4x4_dct_buf) );
502 503
        }
        for( i = h->mb.i_skip_intra ? 15 : 0 ; i < 16; i++ )
Laurent Aimar's avatar
Laurent Aimar committed
504
        {
505
            uint8_t  *p_dst = &h->mb.pic.p_fdec[0][block_idx_xy_fdec[i]];
Laurent Aimar's avatar
Laurent Aimar committed
506 507
            int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];

508 509
            if( (h->mb.i_neighbour4[i] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
                /* emulate missing topright samples */
510
                *(uint32_t*) &p_dst[4-FDEC_STRIDE] = p_dst[3-FDEC_STRIDE] * 0x01010101U;
511

512 513 514 515
            if( h->mb.b_lossless )
                x264_predict_lossless_4x4( h, p_dst, i, i_mode );
            else
                h->predict_4x4[i_mode]( p_dst );
516
            x264_mb_encode_i4x4( h, i, i_qp );
Laurent Aimar's avatar
Laurent Aimar committed
517 518 519 520
        }
    }
    else    /* Inter MB */
    {
521
        int i8x8, i4x4;
Laurent Aimar's avatar
Laurent Aimar committed
522 523
        int i_decimate_mb = 0;

524 525 526
        /* Don't repeat motion compensation if it was already done in non-RD transform analysis */
        if( !h->mb.b_skip_mc )
            x264_mb_mc( h );
Laurent Aimar's avatar
Laurent Aimar committed
527

Loren Merritt's avatar
Loren Merritt committed
528 529
        if( h->mb.b_lossless )
        {
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
            if( h->mb.b_transform_8x8 )
                for( i8x8 = 0; i8x8 < 4; i8x8++ )
                {
                    int x = 8*(i8x8&1);
                    int y = 8*(i8x8>>1);
                    h->zigzagf.sub_8x8( h->dct.luma8x8[i8x8],
                                        h->mb.pic.p_fenc[0]+x+y*FENC_STRIDE,
                                        h->mb.pic.p_fdec[0]+x+y*FDEC_STRIDE );
                    nnz8x8[i8x8] = array_non_zero( h->dct.luma8x8[i8x8] );
                }
            else
                for( i4x4 = 0; i4x4 < 16; i4x4++ )
                {
                    h->zigzagf.sub_4x4( h->dct.luma4x4[i4x4],
                                        h->mb.pic.p_fenc[0]+block_idx_xy_fenc[i4x4],
                                        h->mb.pic.p_fdec[0]+block_idx_xy_fdec[i4x4] );
                }
Loren Merritt's avatar
Loren Merritt committed
547 548
        }
        else if( h->mb.b_transform_8x8 )
Laurent Aimar's avatar
Laurent Aimar committed
549
        {
Loren Merritt's avatar
Loren Merritt committed
550
            DECLARE_ALIGNED_16( int16_t dct8x8[4][8][8] );
551
            b_decimate &= !h->mb.b_trellis; // 8x8 trellis is inherently optimal decimation
552
            h->dctf.sub16x16_dct8( dct8x8, h->mb.pic.p_fenc[0], h->mb.pic.p_fdec[0] );
Fiona Glaser's avatar
Fiona Glaser committed
553
            h->nr_count[1] += h->mb.b_noise_reduction * 4;
Laurent Aimar's avatar
Laurent Aimar committed
554

555
            for( idx = 0; idx < 4; idx++ )
Laurent Aimar's avatar
Laurent Aimar committed
556
            {
557
                if( h->mb.b_noise_reduction )
Loren Merritt's avatar
Loren Merritt committed
558
                    h->quantf.denoise_dct( *dct8x8[idx], h->nr_residual_sum[1], h->nr_offset[1], 64 );
559
                x264_quant_8x8( h, dct8x8[idx], i_qp, 0, idx );
Laurent Aimar's avatar
Laurent Aimar committed
560

561
                h->zigzagf.scan_8x8( h->dct.luma8x8[idx], dct8x8[idx] );
Laurent Aimar's avatar
Laurent Aimar committed
562

563
                if( b_decimate )
564
                {
Loren Merritt's avatar
Loren Merritt committed
565 566 567
                    int i_decimate_8x8 = x264_mb_decimate_score( h->dct.luma8x8[idx], 64 );
                    i_decimate_mb += i_decimate_8x8;
                    if( i_decimate_8x8 < 4 )
568
                        nnz8x8[idx] = 0;
569
                }
570
                else
571
                    nnz8x8[idx] = array_non_zero( dct8x8[idx] );
Laurent Aimar's avatar
Laurent Aimar committed
572 573
            }

574
            if( i_decimate_mb < 6 && b_decimate )
575
                *(uint32_t*)nnz8x8 = 0;
576
            else
577 578 579 580 581
            {
                for( idx = 0; idx < 4; idx++ )
                    if( nnz8x8[idx] )
                    {
                        h->quantf.dequant_8x8( dct8x8[idx], h->dequant8_mf[CQM_8PY], i_qp );
582
                        h->dctf.add8x8_idct8( &h->mb.pic.p_fdec[0][(idx&1)*8 + (idx>>1)*8*FDEC_STRIDE], dct8x8[idx] );
583 584
                    }
            }
585 586 587
        }
        else
        {
Loren Merritt's avatar
Loren Merritt committed
588
            DECLARE_ALIGNED_16( int16_t dct4x4[16][4][4] );
589
            h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], h->mb.pic.p_fdec[0] );
Fiona Glaser's avatar
Fiona Glaser committed
590
            h->nr_count[0] += h->mb.b_noise_reduction * 16;
591 592

            for( i8x8 = 0; i8x8 < 4; i8x8++ )
Laurent Aimar's avatar
Laurent Aimar committed
593
            {
594 595 596 597
                int i_decimate_8x8;

                /* encode one 4x4 block */
                i_decimate_8x8 = 0;
Laurent Aimar's avatar
Laurent Aimar committed
598 599 600
                for( i4x4 = 0; i4x4 < 4; i4x4++ )
                {
                    idx = i8x8 * 4 + i4x4;
601

602
                    if( h->mb.b_noise_reduction )
Loren Merritt's avatar
Loren Merritt committed
603
                        h->quantf.denoise_dct( *dct4x4[idx], h->nr_residual_sum[0], h->nr_offset[0], 16 );
604
                    x264_quant_4x4( h, dct4x4[idx], i_qp, DCT_LUMA_4x4, 0, idx );
Loren Merritt's avatar
Loren Merritt committed
605

606
                    h->zigzagf.scan_4x4( h->dct.luma4x4[idx], dct4x4[idx] );
607 608

                    if( b_decimate && i_decimate_8x8 <= 6 )
609
                        i_decimate_8x8 += x264_mb_decimate_score( h->dct.luma4x4[idx], 16 );
Laurent Aimar's avatar
Laurent Aimar committed
610 611
                }

612 613
                /* decimate this 8x8 block */
                i_decimate_mb += i_decimate_8x8;
614
                if( i_decimate_8x8 < 4 && b_decimate )
615
                    nnz8x8[i8x8] = 0;
Laurent Aimar's avatar
Laurent Aimar committed
616
            }
617

618
            if( i_decimate_mb < 6 && b_decimate )
619
                *(uint32_t*)nnz8x8 = 0;
620
            else
621 622 623 624 625 626
            {
                for( i8x8 = 0; i8x8 < 4; i8x8++ )
                    if( nnz8x8[i8x8] )
                    {
                        for( i = 0; i < 4; i++ )
                            h->quantf.dequant_4x4( dct4x4[i8x8*4+i], h->dequant4_mf[CQM_4PY], i_qp );
627
                        h->dctf.add8x8_idct( &h->mb.pic.p_fdec[0][(i8x8&1)*8 + (i8x8>>1)*8*FDEC_STRIDE], &dct4x4[i8x8*4] );
628 629
                    }
            }
Laurent Aimar's avatar
Laurent Aimar committed
630 631 632 633 634 635 636
        }
    }

    /* encode chroma */
    if( IS_INTRA( h->mb.i_type ) )
    {
        const int i_mode = h->mb.i_chroma_pred_mode;
637 638 639 640 641 642 643
        if( h->mb.b_lossless )
            x264_predict_lossless_8x8_chroma( h, i_mode );
        else
        {
            h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
            h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
        }
Laurent Aimar's avatar
Laurent Aimar committed
644 645 646
    }

    /* encode the 8x8 blocks */
647
    x264_mb_encode_8x8_chroma( h, !IS_INTRA( h->mb.i_type ), h->mb.i_chroma_qp );
Laurent Aimar's avatar
Laurent Aimar committed
648

649
    /* coded block pattern and non_zero_count */
650
    h->mb.i_cbp_luma = 0x00;
Laurent Aimar's avatar
Laurent Aimar committed
651 652 653 654
    if( h->mb.i_type == I_16x16 )
    {
        for( i = 0; i < 16; i++ )
        {
655
            int nz = array_non_zero( h->dct.luma4x4[i] );
Laurent Aimar's avatar
Laurent Aimar committed
656
            h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
657
            h->mb.i_cbp_luma |= nz;
Laurent Aimar's avatar
Laurent Aimar committed
658
        }
659
        h->mb.i_cbp_luma *= 0xf;
Laurent Aimar's avatar
Laurent Aimar committed
660 661 662
    }
    else
    {
663
        for( i = 0; i < 4; i++)
Laurent Aimar's avatar
Laurent Aimar committed
664
        {
665
            if(!nnz8x8[i])
666 667 668 669
            {
                *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[0+i*4]] = 0;
                *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[2+i*4]] = 0;
            }
670 671
            else if( h->mb.b_transform_8x8 )
            {
672 673 674
                *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[0+4*i]] = nnz8x8[i] * 0x0101;
                *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[2+4*i]] = nnz8x8[i] * 0x0101;
                h->mb.i_cbp_luma |= nnz8x8[i] << i;
675 676 677
            }
            else
            {
678
                int nz, cbp = 0;
679 680
                for( j = 0; j < 4; j++ )
                {
681 682 683
                    nz = array_non_zero( h->dct.luma4x4[j+4*i] );
                    h->mb.cache.non_zero_count[x264_scan8[j+4*i]] = nz;
                    cbp |= nz;
684
                }
685
                h->mb.i_cbp_luma |= cbp << i;
686
            }
Laurent Aimar's avatar
Laurent Aimar committed
687 688 689 690 691
        }
    }

    if( h->param.b_cabac )
    {
692 693 694
        i_cbp_dc = ( h->mb.i_type == I_16x16 && array_non_zero( h->dct.luma16x16_dc ) )
                 | array_non_zero( h->dct.chroma_dc[0] ) << 1
                 | array_non_zero( h->dct.chroma_dc[1] ) << 2;
Laurent Aimar's avatar
Laurent Aimar committed
695 696 697 698 699 700 701 702
    }

    /* store cbp */
    h->mb.cbp[h->mb.i_mb_xy] = (i_cbp_dc << 8) | (h->mb.i_cbp_chroma << 4) | h->mb.i_cbp_luma;

    /* Check for P_SKIP
     * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
     *      (if multiple mv give same result)*/
703
    if( !b_force_no_skip )
Laurent Aimar's avatar
Laurent Aimar committed
704
    {
705
        if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
Loren Merritt's avatar
Loren Merritt committed
706
            !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) &&
707 708
            *(uint32_t*)h->mb.cache.mv[0][x264_scan8[0]] == *(uint32_t*)h->mb.cache.pskip_mv
            && h->mb.cache.ref[0][x264_scan8[0]] == 0 )
709
        {
710
            h->mb.i_type = P_SKIP;
Laurent Aimar's avatar
Laurent Aimar committed
711
        }
712

713
        /* Check for B_SKIP */
714
        if( h->mb.i_type == B_DIRECT && !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) )
715 716 717
        {
            h->mb.i_type = B_SKIP;
        }
718
    }
Laurent Aimar's avatar
Laurent Aimar committed
719 720 721
}

/*****************************************************************************
722 723
 * x264_macroblock_probe_skip:
 *  Check if the current MB could be encoded as a [PB]_SKIP (it supposes you use
Laurent Aimar's avatar
Laurent Aimar committed
724 725
 *  the previous QP
 *****************************************************************************/
726
int x264_macroblock_probe_skip( x264_t *h, const int b_bidir )
Laurent Aimar's avatar
Laurent Aimar committed
727
{
Fiona Glaser's avatar
Fiona Glaser committed
728
    DECLARE_ALIGNED_16( int16_t dct4x4[4][4][4] );
Loren Merritt's avatar
Loren Merritt committed
729 730
    DECLARE_ALIGNED_16( int16_t dct2x2[2][2] );
    DECLARE_ALIGNED_16( int16_t dctscan[16] );
Laurent Aimar's avatar
Laurent Aimar committed
731

732
    int i_qp = h->mb.i_qp;
Laurent Aimar's avatar
Laurent Aimar committed
733
    int mvp[2];
734
    int ch, thresh;
Laurent Aimar's avatar
Laurent Aimar committed
735 736 737 738

    int i8x8, i4x4;
    int i_decimate_mb;

739 740 741
    if( !b_bidir )
    {
        /* Get the MV */
742 743
        mvp[0] = x264_clip3( h->mb.cache.pskip_mv[0], h->mb.mv_min[0], h->mb.mv_max[0] );
        mvp[1] = x264_clip3( h->mb.cache.pskip_mv[1], h->mb.mv_min[1], h->mb.mv_max[1] );
Laurent Aimar's avatar
Laurent Aimar committed
744

745
        /* Motion compensation */
746 747
        h->mc.mc_luma( h->mb.pic.p_fdec[0],    FDEC_STRIDE,
                       h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
748
                       mvp[0], mvp[1], 16, 16 );
749
    }
Laurent Aimar's avatar
Laurent Aimar committed
750 751 752

    for( i8x8 = 0, i_decimate_mb = 0; i8x8 < 4; i8x8++ )
    {
Fiona Glaser's avatar
Fiona Glaser committed
753 754 755 756 757
        int fenc_offset = (i8x8&1) * 8 + (i8x8>>1) * FENC_STRIDE * 8;
        int fdec_offset = (i8x8&1) * 8 + (i8x8>>1) * FDEC_STRIDE * 8;
        /* get luma diff */
        h->dctf.sub8x8_dct( dct4x4, h->mb.pic.p_fenc[0] + fenc_offset,
                                    h->mb.pic.p_fdec[0] + fdec_offset );
Laurent Aimar's avatar
Laurent Aimar committed
758 759 760
        /* encode one 4x4 block */
        for( i4x4 = 0; i4x4 < 4; i4x4++ )
        {
Fiona Glaser's avatar
Fiona Glaser committed
761 762 763 764
            h->quantf.quant_4x4( dct4x4[i4x4], h->quant4_mf[CQM_4PY][i_qp], h->quant4_bias[CQM_4PY][i_qp] );
            if( !array_non_zero(dct4x4[i4x4]) )
                continue;
            h->zigzagf.scan_4x4( dctscan, dct4x4[i4x4] );
Laurent Aimar's avatar
Laurent Aimar committed
765 766 767 768 769 770 771
            i_decimate_mb += x264_mb_decimate_score( dctscan, 16 );
            if( i_decimate_mb >= 6 )
                return 0;
        }
    }

    /* encode chroma */
772
    i_qp = h->mb.i_chroma_qp;
773
    thresh = (x264_lambda2_tab[i_qp] + 32) >> 6;
Laurent Aimar's avatar
Laurent Aimar committed
774 775 776 777 778 779

    for( ch = 0; ch < 2; ch++ )
    {
        uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
        uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];

780 781
        if( !b_bidir )
        {
782 783
            h->mc.mc_chroma( h->mb.pic.p_fdec[1+ch],       FDEC_STRIDE,
                             h->mb.pic.p_fref[0][0][4+ch], h->mb.pic.i_stride[1+ch],
784
                             mvp[0], mvp[1], 8, 8 );
785
        }
Laurent Aimar's avatar
Laurent Aimar committed
786

787 788 789 790 791
        /* there is almost never a termination during chroma, but we can't avoid the check entirely */
        /* so instead we check SSD and skip the actual check if the score is low enough. */
        if( h->pixf.ssd[PIXEL_8x8]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE ) < thresh )
            continue;

792
        h->dctf.sub8x8_dct( dct4x4, p_src, p_dst );
Laurent Aimar's avatar
Laurent Aimar committed
793 794 795 796 797 798 799

        /* calculate dct DC */
        dct2x2[0][0] = dct4x4[0][0][0];
        dct2x2[0][1] = dct4x4[1][0][0];
        dct2x2[1][0] = dct4x4[2][0][0];
        dct2x2[1][1] = dct4x4[3][0][0];
        h->dctf.dct2x2dc( dct2x2 );
Loren Merritt's avatar
Loren Merritt committed
800
        h->quantf.quant_2x2_dc( dct2x2, h->quant4_mf[CQM_4PC][i_qp][0]>>1, h->quant4_bias[CQM_4PC][i_qp][0]<<1 );
Fiona Glaser's avatar
Fiona Glaser committed
801
        if( array_non_zero(dct2x2) )
Laurent Aimar's avatar
Laurent Aimar committed
802 803 804 805 806
            return 0;

        /* calculate dct coeffs */
        for( i4x4 = 0, i_decimate_mb = 0; i4x4 < 4; i4x4++ )
        {
Loren Merritt's avatar
Loren Merritt committed
807
            h->quantf.quant_4x4( dct4x4[i4x4], h->quant4_mf[CQM_4PC][i_qp], h->quant4_bias[CQM_4PC][i_qp] );
Fiona Glaser's avatar
Fiona Glaser committed
808 809
            if( !array_non_zero(dct4x4[i4x4]) )
                continue;
810 811
            h->zigzagf.scan_4x4( dctscan, dct4x4[i4x4] );
            i_decimate_mb += x264_mb_decimate_score( dctscan+1, 15 );
Laurent Aimar's avatar
Laurent Aimar committed
812 813 814 815 816
            if( i_decimate_mb >= 7 )
                return 0;
        }
    }

817
    h->mb.b_skip_mc = 1;
Laurent Aimar's avatar
Laurent Aimar committed
818 819
    return 1;
}
820 821 822 823 824 825 826 827 828

/****************************************************************************
 * DCT-domain noise reduction / adaptive deadzone
 * from libavcodec
 ****************************************************************************/

void x264_noise_reduction_update( x264_t *h )
{
    int cat, i;
829
    for( cat = 0; cat < 2; cat++ )
830
    {
831
        int size = cat ? 64 : 16;
832
        const uint16_t *weight = cat ? x264_dct8_weight2_tab : x264_dct4_weight2_tab;
833

834
        if( h->nr_count[cat] > (cat ? (1<<16) : (1<<18)) )
835 836 837 838 839 840 841 842 843 844 845 846 847 848
        {
            for( i = 0; i < size; i++ )
                h->nr_residual_sum[cat][i] >>= 1;
            h->nr_count[cat] >>= 1;
        }

        for( i = 0; i < size; i++ )
            h->nr_offset[cat][i] =
                ((uint64_t)h->param.analyse.i_noise_reduction * h->nr_count[cat]
                 + h->nr_residual_sum[cat][i]/2)
              / ((uint64_t)h->nr_residual_sum[cat][i] * weight[i]/256 + 1);
    }
}

849 850 851 852 853 854 855 856 857
/*****************************************************************************
 * RD only; 4 calls to this do not make up for one macroblock_encode.
 * doesn't transform chroma dc.
 *****************************************************************************/
void x264_macroblock_encode_p8x8( x264_t *h, int i8 )
{
    int i_qp = h->mb.i_qp;
    uint8_t *p_fenc = h->mb.pic.p_fenc[0] + (i8&1)*8 + (i8>>1)*8*FENC_STRIDE;
    uint8_t *p_fdec = h->mb.pic.p_fdec[0] + (i8&1)*8 + (i8>>1)*8*FDEC_STRIDE;
858
    int b_decimate = h->sh.i_type == SLICE_TYPE_B || h->param.analyse.b_dct_decimate;
859
    int nnz8x8 = 0;
860 861 862 863
    int ch;

    x264_mb_mc_8x8( h, i8 );

864
    if( h->mb.b_lossless )
865
    {
866
        int i4;
867 868 869 870 871 872