Revision 86b0d9cd libavcodec/h264_loopfilter.c

View differences:

libavcodec/h264_loopfilter.c
101 101 
};
102 102 

  		




  103
  103
  
    
static void av_always_inline filter_mb_edgev( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h) {


  		




  104
  
  
    
    const unsigned int index_a = qp + h->slice_alpha_c0_offset;


  		




  105
  
  
    
    const int alpha = alpha_table[index_a];


  		




  106
  
  
    
    const int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  104
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  105
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  106
  
    
    const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  107
  
    
    const int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  108
  
    
    const int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  107
  109
  
    
    if (alpha ==0 || beta == 0) return;


  		




  108
  110
  
    

  		




  109
  111
  
    
    if( bS[0] < 4 ) {


  		




  110
  112
  
    
        int8_t tc[4];


  		




  111
  
  
    
        tc[0] = tc0_table[index_a][bS[0]];


  		




  112
  
  
    
        tc[1] = tc0_table[index_a][bS[1]];


  		




  113
  
  
    
        tc[2] = tc0_table[index_a][bS[2]];


  		




  114
  
  
    
        tc[3] = tc0_table[index_a][bS[3]];


  		




  
  113
  
    
        tc[0] = tc0_table[index_a][bS[0]] << (bit_depth-8);


  		




  
  114
  
    
        tc[1] = tc0_table[index_a][bS[1]] << (bit_depth-8);


  		




  
  115
  
    
        tc[2] = tc0_table[index_a][bS[2]] << (bit_depth-8);


  		




  
  116
  
    
        tc[3] = tc0_table[index_a][bS[3]] << (bit_depth-8);


  		




  115
  117
  
    
        h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);


  		




  116
  118
  
    
    } else {


  		




  117
  119
  
    
        h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);


  		




  118
  120
  
    
    }


  		




  119
  121
  
    
}


  		




  120
  122
  
    
static void av_always_inline filter_mb_edgecv( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {


  		




  121
  
  
    
    const unsigned int index_a = qp + h->slice_alpha_c0_offset;


  		




  122
  
  
    
    const int alpha = alpha_table[index_a];


  		




  123
  
  
    
    const int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  123
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  124
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  125
  
    
    const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  126
  
    
    const int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  127
  
    
    const int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  124
  128
  
    
    if (alpha ==0 || beta == 0) return;


  		




  125
  129
  
    

  		




  126
  130
  
    
    if( bS[0] < 4 ) {


  		




  127
  131
  
    
        int8_t tc[4];


  		




  128
  
  
    
        tc[0] = tc0_table[index_a][bS[0]]+1;


  		




  129
  
  
    
        tc[1] = tc0_table[index_a][bS[1]]+1;


  		




  130
  
  
    
        tc[2] = tc0_table[index_a][bS[2]]+1;


  		




  131
  
  
    
        tc[3] = tc0_table[index_a][bS[3]]+1;


  		




  
  132
  
    
        tc[0] = (tc0_table[index_a][bS[0]] << (bit_depth-8))+1;


  		




  
  133
  
    
        tc[1] = (tc0_table[index_a][bS[1]] << (bit_depth-8))+1;


  		




  
  134
  
    
        tc[2] = (tc0_table[index_a][bS[2]] << (bit_depth-8))+1;


  		




  
  135
  
    
        tc[3] = (tc0_table[index_a][bS[3]] << (bit_depth-8))+1;


  		




  132
  136
  
    
        h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);


  		




  133
  137
  
    
    } else {


  		




  134
  138
  
    
        h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);


  		




  ......




  137
  141
  
    

  		




  138
  142
  
    
static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) {


  		




  139
  143
  
    
    int i;


  		




  140
  
  
    
    int index_a = qp + h->slice_alpha_c0_offset;


  		




  141
  
  
    
    int alpha = alpha_table[index_a];


  		




  142
  
  
    
    int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  144
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  145
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  146
  
    
    int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  147
  
    
    int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  148
  
    
    int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  143
  149
  
    
    for( i = 0; i < 8; i++, pix += stride) {


  		




  144
  150
  
    
        const int bS_index = (i >> 1) * bsi;


  		




  145
  151
  
    

  		




  ......




  148
  154
  
    
        }


  		




  149
  155
  
    

  		




  150
  156
  
    
        if( bS[bS_index] < 4 ) {


  		




  151
  
  
    
            const int tc0 = tc0_table[index_a][bS[bS_index]];


  		




  
  157
  
    
            const int tc0 = tc0_table[index_a][bS[bS_index]] << (bit_depth-8);


  		




  152
  158
  
    
            const int p0 = pix[-1];


  		




  153
  159
  
    
            const int p1 = pix[-2];


  		




  154
  160
  
    
            const int p2 = pix[-3];


  		




  ......




  226
  232
  
    
}


  		




  227
  233
  
    
static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) {


  		




  228
  234
  
    
    int i;


  		




  229
  
  
    
    int index_a = qp + h->slice_alpha_c0_offset;


  		




  230
  
  
    
    int alpha = alpha_table[index_a];


  		




  231
  
  
    
    int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  235
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  236
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  237
  
    
    int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  238
  
    
    int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  239
  
    
    int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  232
  240
  
    
    for( i = 0; i < 4; i++, pix += stride) {


  		




  233
  241
  
    
        const int bS_index = i*bsi;


  		




  234
  242
  
    

  		




  ......




  237
  245
  
    
        }


  		




  238
  246
  
    

  		




  239
  247
  
    
        if( bS[bS_index] < 4 ) {


  		




  240
  
  
    
            const int tc = tc0_table[index_a][bS[bS_index]] + 1;


  		




  
  248
  
    
            const int tc = (tc0_table[index_a][bS[bS_index]] << (bit_depth-8)) + 1;


  		




  241
  249
  
    
            const int p0 = pix[-1];


  		




  242
  250
  
    
            const int p1 = pix[-2];


  		




  243
  251
  
    
            const int q0 = pix[0];


  		




  ......




  271
  279
  
    
}


  		




  272
  280
  
    

  		




  273
  281
  
    
static void av_always_inline filter_mb_edgeh( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {


  		




  274
  
  
    
    const unsigned int index_a = qp + h->slice_alpha_c0_offset;


  		




  275
  
  
    
    const int alpha = alpha_table[index_a];


  		




  276
  
  
    
    const int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  282
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  283
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  284
  
    
    const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  285
  
    
    const int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  286
  
    
    const int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  277
  287
  
    
    if (alpha ==0 || beta == 0) return;


  		




  278
  288
  
    

  		




  279
  289
  
    
    if( bS[0] < 4 ) {


  		




  280
  290
  
    
        int8_t tc[4];


  		




  281
  
  
    
        tc[0] = tc0_table[index_a][bS[0]];


  		




  282
  
  
    
        tc[1] = tc0_table[index_a][bS[1]];


  		




  283
  
  
    
        tc[2] = tc0_table[index_a][bS[2]];


  		




  284
  
  
    
        tc[3] = tc0_table[index_a][bS[3]];


  		




  
  291
  
    
        tc[0] = tc0_table[index_a][bS[0]] << (bit_depth-8);


  		




  
  292
  
    
        tc[1] = tc0_table[index_a][bS[1]] << (bit_depth-8);


  		




  
  293
  
    
        tc[2] = tc0_table[index_a][bS[2]] << (bit_depth-8);


  		




  
  294
  
    
        tc[3] = tc0_table[index_a][bS[3]] << (bit_depth-8);


  		




  285
  295
  
    
        h->h264dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);


  		




  286
  296
  
    
    } else {


  		




  287
  297
  
    
        h->h264dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta);


  		




  ......




  289
  299
  
    
}


  		




  290
  300
  
    

  		




  291
  301
  
    
static void av_always_inline filter_mb_edgech( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {


  		




  292
  
  
    
    const unsigned int index_a = qp + h->slice_alpha_c0_offset;


  		




  293
  
  
    
    const int alpha = alpha_table[index_a];


  		




  294
  
  
    
    const int beta  = beta_table[qp + h->slice_beta_offset];


  		




  
  302
  
    
    const int bit_depth = h->sps.bit_depth_luma;


  		




  
  303
  
    
    const int qp_bd_offset = 6*(bit_depth-8);


  		




  
  304
  
    
    const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;


  		




  
  305
  
    
    const int alpha = alpha_table[index_a] << (bit_depth-8);


  		




  
  306
  
    
    const int beta  = beta_table[qp - qp_bd_offset + h->slice_beta_offset] << (bit_depth-8);


  		




  295
  307
  
    
    if (alpha ==0 || beta == 0) return;


  		




  296
  308
  
    

  		




  297
  309
  
    
    if( bS[0] < 4 ) {


  		




  298
  310
  
    
        int8_t tc[4];


  		




  299
  
  
    
        tc[0] = tc0_table[index_a][bS[0]]+1;


  		




  300
  
  
    
        tc[1] = tc0_table[index_a][bS[1]]+1;


  		




  301
  
  
    
        tc[2] = tc0_table[index_a][bS[2]]+1;


  		




  302
  
  
    
        tc[3] = tc0_table[index_a][bS[3]]+1;


  		




  
  311
  
    
        tc[0] = (tc0_table[index_a][bS[0]] << (bit_depth-8))+1;


  		




  
  312
  
    
        tc[1] = (tc0_table[index_a][bS[1]] << (bit_depth-8))+1;


  		




  
  313
  
    
        tc[2] = (tc0_table[index_a][bS[2]] << (bit_depth-8))+1;


  		




  
  314
  
    
        tc[3] = (tc0_table[index_a][bS[3]] << (bit_depth-8))+1;


  		




  303
  315
  
    
        h->h264dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);


  		




  304
  316
  
    
    } else {


  		




  305
  317
  
    
        h->h264dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);


  		












Also available in:  Unified diff