ffmpeg / libavcodec / h264_loopfilter.c @ dc172ecc
History | View | Annotate | Download (36.1 KB)
| 1 |
/*
|
|---|---|
| 2 |
* H.26L/H.264/AVC/JVT/14496-10/... loop filter
|
| 3 |
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
|
| 4 |
*
|
| 5 |
* This file is part of FFmpeg.
|
| 6 |
*
|
| 7 |
* FFmpeg is free software; you can redistribute it and/or
|
| 8 |
* modify it under the terms of the GNU Lesser General Public
|
| 9 |
* License as published by the Free Software Foundation; either
|
| 10 |
* version 2.1 of the License, or (at your option) any later version.
|
| 11 |
*
|
| 12 |
* FFmpeg is distributed in the hope that it will be useful,
|
| 13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
| 14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
| 15 |
* Lesser General Public License for more details.
|
| 16 |
*
|
| 17 |
* You should have received a copy of the GNU Lesser General Public
|
| 18 |
* License along with FFmpeg; if not, write to the Free Software
|
| 19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
| 20 |
*/
|
| 21 |
|
| 22 |
/**
|
| 23 |
* @file
|
| 24 |
* H.264 / AVC / MPEG4 part10 loop filter.
|
| 25 |
* @author Michael Niedermayer <michaelni@gmx.at>
|
| 26 |
*/
|
| 27 |
|
| 28 |
#include "libavutil/intreadwrite.h" |
| 29 |
#include "internal.h" |
| 30 |
#include "dsputil.h" |
| 31 |
#include "avcodec.h" |
| 32 |
#include "mpegvideo.h" |
| 33 |
#include "h264.h" |
| 34 |
#include "mathops.h" |
| 35 |
#include "rectangle.h" |
| 36 |
|
| 37 |
//#undef NDEBUG
|
| 38 |
#include <assert.h> |
| 39 |
|
| 40 |
/* Deblocking filter (p153) */
|
| 41 |
static const uint8_t alpha_table[52*3] = { |
| 42 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 43 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 44 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 45 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 46 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 47 |
0, 0, 0, 0, 0, 0, 4, 4, 5, 6, |
| 48 |
7, 8, 9, 10, 12, 13, 15, 17, 20, 22, |
| 49 |
25, 28, 32, 36, 40, 45, 50, 56, 63, 71, |
| 50 |
80, 90,101,113,127,144,162,182,203,226, |
| 51 |
255,255, |
| 52 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
| 53 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
| 54 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
| 55 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
| 56 |
}; |
| 57 |
static const uint8_t beta_table[52*3] = { |
| 58 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 59 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 60 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 61 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 62 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 63 |
0, 0, 0, 0, 0, 0, 2, 2, 2, 3, |
| 64 |
3, 3, 3, 4, 4, 4, 6, 6, 7, 7, |
| 65 |
8, 8, 9, 9, 10, 10, 11, 11, 12, 12, |
| 66 |
13, 13, 14, 14, 15, 15, 16, 16, 17, 17, |
| 67 |
18, 18, |
| 68 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
| 69 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
| 70 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
| 71 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
| 72 |
}; |
| 73 |
static const uint8_t tc0_table[52*3][4] = { |
| 74 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 75 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 76 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 77 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 78 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 79 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 80 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 81 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 82 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 83 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 84 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
|
| 85 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 1 },
|
| 86 |
{-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 },
|
| 87 |
{-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 },
|
| 88 |
{-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 },
|
| 89 |
{-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 },
|
| 90 |
{-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 },
|
| 91 |
{-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-1,13,17,25 },
|
| 92 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 93 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 94 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 95 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 96 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 97 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 98 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 99 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 100 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
|
| 101 |
}; |
| 102 |
|
| 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 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); |
| 109 |
if (alpha ==0 || beta == 0) return; |
| 110 |
|
| 111 |
if( bS[0] < 4 ) { |
| 112 |
int8_t tc[4];
|
| 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); |
| 117 |
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
| 118 |
} else {
|
| 119 |
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta); |
| 120 |
} |
| 121 |
} |
| 122 |
static void av_always_inline filter_mb_edgecv( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) { |
| 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); |
| 128 |
if (alpha ==0 || beta == 0) return; |
| 129 |
|
| 130 |
if( bS[0] < 4 ) { |
| 131 |
int8_t tc[4];
|
| 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; |
| 136 |
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
| 137 |
} else {
|
| 138 |
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta); |
| 139 |
} |
| 140 |
} |
| 141 |
|
| 142 |
static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) { |
| 143 |
int i;
|
| 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); |
| 149 |
for( i = 0; i < 8; i++, pix += stride) { |
| 150 |
const int bS_index = (i >> 1) * bsi; |
| 151 |
|
| 152 |
if( bS[bS_index] == 0 ) { |
| 153 |
continue;
|
| 154 |
} |
| 155 |
|
| 156 |
if( bS[bS_index] < 4 ) { |
| 157 |
const int tc0 = tc0_table[index_a][bS[bS_index]] << (bit_depth-8); |
| 158 |
const int p0 = pix[-1]; |
| 159 |
const int p1 = pix[-2]; |
| 160 |
const int p2 = pix[-3]; |
| 161 |
const int q0 = pix[0]; |
| 162 |
const int q1 = pix[1]; |
| 163 |
const int q2 = pix[2]; |
| 164 |
|
| 165 |
if( FFABS( p0 - q0 ) < alpha &&
|
| 166 |
FFABS( p1 - p0 ) < beta && |
| 167 |
FFABS( q1 - q0 ) < beta ) {
|
| 168 |
int tc = tc0;
|
| 169 |
int i_delta;
|
| 170 |
|
| 171 |
if( FFABS( p2 - p0 ) < beta ) {
|
| 172 |
if(tc0)
|
| 173 |
pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); |
| 174 |
tc++; |
| 175 |
} |
| 176 |
if( FFABS( q2 - q0 ) < beta ) {
|
| 177 |
if(tc0)
|
| 178 |
pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); |
| 179 |
tc++; |
| 180 |
} |
| 181 |
|
| 182 |
i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
| 183 |
pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ |
| 184 |
pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ |
| 185 |
tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
| 186 |
} |
| 187 |
}else{
|
| 188 |
const int p0 = pix[-1]; |
| 189 |
const int p1 = pix[-2]; |
| 190 |
const int p2 = pix[-3]; |
| 191 |
|
| 192 |
const int q0 = pix[0]; |
| 193 |
const int q1 = pix[1]; |
| 194 |
const int q2 = pix[2]; |
| 195 |
|
| 196 |
if( FFABS( p0 - q0 ) < alpha &&
|
| 197 |
FFABS( p1 - p0 ) < beta && |
| 198 |
FFABS( q1 - q0 ) < beta ) {
|
| 199 |
|
| 200 |
if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
| 201 |
if( FFABS( p2 - p0 ) < beta)
|
| 202 |
{
|
| 203 |
const int p3 = pix[-4]; |
| 204 |
/* p0', p1', p2' */
|
| 205 |
pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; |
| 206 |
pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; |
| 207 |
pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; |
| 208 |
} else {
|
| 209 |
/* p0' */
|
| 210 |
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; |
| 211 |
} |
| 212 |
if( FFABS( q2 - q0 ) < beta)
|
| 213 |
{
|
| 214 |
const int q3 = pix[3]; |
| 215 |
/* q0', q1', q2' */
|
| 216 |
pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; |
| 217 |
pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; |
| 218 |
pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; |
| 219 |
} else {
|
| 220 |
/* q0' */
|
| 221 |
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; |
| 222 |
} |
| 223 |
}else{
|
| 224 |
/* p0', q0' */
|
| 225 |
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; |
| 226 |
pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; |
| 227 |
} |
| 228 |
tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]); |
| 229 |
} |
| 230 |
} |
| 231 |
} |
| 232 |
} |
| 233 |
static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) { |
| 234 |
int i;
|
| 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); |
| 240 |
for( i = 0; i < 4; i++, pix += stride) { |
| 241 |
const int bS_index = i*bsi; |
| 242 |
|
| 243 |
if( bS[bS_index] == 0 ) { |
| 244 |
continue;
|
| 245 |
} |
| 246 |
|
| 247 |
if( bS[bS_index] < 4 ) { |
| 248 |
const int tc = (tc0_table[index_a][bS[bS_index]] << (bit_depth-8)) + 1; |
| 249 |
const int p0 = pix[-1]; |
| 250 |
const int p1 = pix[-2]; |
| 251 |
const int q0 = pix[0]; |
| 252 |
const int q1 = pix[1]; |
| 253 |
|
| 254 |
if( FFABS( p0 - q0 ) < alpha &&
|
| 255 |
FFABS( p1 - p0 ) < beta && |
| 256 |
FFABS( q1 - q0 ) < beta ) {
|
| 257 |
const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
| 258 |
|
| 259 |
pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ |
| 260 |
pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ |
| 261 |
tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
| 262 |
} |
| 263 |
}else{
|
| 264 |
const int p0 = pix[-1]; |
| 265 |
const int p1 = pix[-2]; |
| 266 |
const int q0 = pix[0]; |
| 267 |
const int q1 = pix[1]; |
| 268 |
|
| 269 |
if( FFABS( p0 - q0 ) < alpha &&
|
| 270 |
FFABS( p1 - p0 ) < beta && |
| 271 |
FFABS( q1 - q0 ) < beta ) {
|
| 272 |
|
| 273 |
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ |
| 274 |
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ |
| 275 |
tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]); |
| 276 |
} |
| 277 |
} |
| 278 |
} |
| 279 |
} |
| 280 |
|
| 281 |
static void av_always_inline filter_mb_edgeh( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) { |
| 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); |
| 287 |
if (alpha ==0 || beta == 0) return; |
| 288 |
|
| 289 |
if( bS[0] < 4 ) { |
| 290 |
int8_t tc[4];
|
| 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); |
| 295 |
h->h264dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
| 296 |
} else {
|
| 297 |
h->h264dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta); |
| 298 |
} |
| 299 |
} |
| 300 |
|
| 301 |
static void av_always_inline filter_mb_edgech( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) { |
| 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); |
| 307 |
if (alpha ==0 || beta == 0) return; |
| 308 |
|
| 309 |
if( bS[0] < 4 ) { |
| 310 |
int8_t tc[4];
|
| 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; |
| 315 |
h->h264dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
| 316 |
} else {
|
| 317 |
h->h264dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta); |
| 318 |
} |
| 319 |
} |
| 320 |
|
| 321 |
void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { |
| 322 |
MpegEncContext * const s = &h->s;
|
| 323 |
int mb_xy;
|
| 324 |
int mb_type, left_type;
|
| 325 |
int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;
|
| 326 |
|
| 327 |
mb_xy = h->mb_xy; |
| 328 |
|
| 329 |
if(!h->top_type || !h->h264dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff) {
|
| 330 |
ff_h264_filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize); |
| 331 |
return;
|
| 332 |
} |
| 333 |
assert(!FRAME_MBAFF); |
| 334 |
left_type= h->left_type[0];
|
| 335 |
|
| 336 |
mb_type = s->current_picture.mb_type[mb_xy]; |
| 337 |
qp = s->current_picture.qscale_table[mb_xy]; |
| 338 |
qp0 = s->current_picture.qscale_table[mb_xy-1];
|
| 339 |
qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
| 340 |
qpc = get_chroma_qp( h, 0, qp );
|
| 341 |
qpc0 = get_chroma_qp( h, 0, qp0 );
|
| 342 |
qpc1 = get_chroma_qp( h, 0, qp1 );
|
| 343 |
qp0 = (qp + qp0 + 1) >> 1; |
| 344 |
qp1 = (qp + qp1 + 1) >> 1; |
| 345 |
qpc0 = (qpc + qpc0 + 1) >> 1; |
| 346 |
qpc1 = (qpc + qpc1 + 1) >> 1; |
| 347 |
qp_thresh = 15+52 - h->slice_alpha_c0_offset; |
| 348 |
if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh &&
|
| 349 |
qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) |
| 350 |
return;
|
| 351 |
|
| 352 |
if( IS_INTRA(mb_type) ) {
|
| 353 |
int16_t bS4[4] = {4,4,4,4}; |
| 354 |
int16_t bS3[4] = {3,3,3,3}; |
| 355 |
int16_t *bSH = FIELD_PICTURE ? bS3 : bS4; |
| 356 |
if(left_type)
|
| 357 |
filter_mb_edgev( &img_y[4*0], linesize, bS4, qp0, h); |
| 358 |
if( IS_8x8DCT(mb_type) ) {
|
| 359 |
filter_mb_edgev( &img_y[4*2], linesize, bS3, qp, h); |
| 360 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, h); |
| 361 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, h); |
| 362 |
} else {
|
| 363 |
filter_mb_edgev( &img_y[4*1], linesize, bS3, qp, h); |
| 364 |
filter_mb_edgev( &img_y[4*2], linesize, bS3, qp, h); |
| 365 |
filter_mb_edgev( &img_y[4*3], linesize, bS3, qp, h); |
| 366 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, h); |
| 367 |
filter_mb_edgeh( &img_y[4*1*linesize], linesize, bS3, qp, h); |
| 368 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, h); |
| 369 |
filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, h); |
| 370 |
} |
| 371 |
if(left_type){
|
| 372 |
filter_mb_edgecv( &img_cb[2*0], uvlinesize, bS4, qpc0, h); |
| 373 |
filter_mb_edgecv( &img_cr[2*0], uvlinesize, bS4, qpc0, h); |
| 374 |
} |
| 375 |
filter_mb_edgecv( &img_cb[2*2], uvlinesize, bS3, qpc, h); |
| 376 |
filter_mb_edgecv( &img_cr[2*2], uvlinesize, bS3, qpc, h); |
| 377 |
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, h); |
| 378 |
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, h); |
| 379 |
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, h); |
| 380 |
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, h); |
| 381 |
return;
|
| 382 |
} else {
|
| 383 |
LOCAL_ALIGNED_8(int16_t, bS, [2], [4][4]); |
| 384 |
int edges;
|
| 385 |
if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { |
| 386 |
edges = 4;
|
| 387 |
AV_WN64A(bS[0][0], 0x0002000200020002ULL); |
| 388 |
AV_WN64A(bS[0][2], 0x0002000200020002ULL); |
| 389 |
AV_WN64A(bS[1][0], 0x0002000200020002ULL); |
| 390 |
AV_WN64A(bS[1][2], 0x0002000200020002ULL); |
| 391 |
} else {
|
| 392 |
int mask_edge1 = (3*(((5*mb_type)>>5)&1)) | (mb_type>>4); //(mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : (mb_type & MB_TYPE_16x8) ? 1 : 0; |
| 393 |
int mask_edge0 = 3*((mask_edge1>>1) & ((5*left_type)>>5)&1); // (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) && (h->left_type[0] & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : 0; |
| 394 |
int step = 1+(mb_type>>24); //IS_8x8DCT(mb_type) ? 2 : 1; |
| 395 |
edges = 4 - 3*((mb_type>>3) & !(h->cbp & 15)); //(mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; |
| 396 |
h->h264dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, |
| 397 |
h->list_count==2, edges, step, mask_edge0, mask_edge1, FIELD_PICTURE);
|
| 398 |
} |
| 399 |
if( IS_INTRA(left_type) )
|
| 400 |
AV_WN64A(bS[0][0], 0x0004000400040004ULL); |
| 401 |
if( IS_INTRA(h->top_type) )
|
| 402 |
AV_WN64A(bS[1][0], FIELD_PICTURE ? 0x0003000300030003ULL : 0x0004000400040004ULL); |
| 403 |
|
| 404 |
#define FILTER(hv,dir,edge)\
|
| 405 |
if(AV_RN64A(bS[dir][edge])) { \
|
| 406 |
filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir, h );\ |
| 407 |
if(!(edge&1)) {\ |
| 408 |
filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\ |
| 409 |
filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\ |
| 410 |
}\ |
| 411 |
} |
| 412 |
if(left_type)
|
| 413 |
FILTER(v,0,0); |
| 414 |
if( edges == 1 ) { |
| 415 |
FILTER(h,1,0); |
| 416 |
} else if( IS_8x8DCT(mb_type) ) { |
| 417 |
FILTER(v,0,2); |
| 418 |
FILTER(h,1,0); |
| 419 |
FILTER(h,1,2); |
| 420 |
} else {
|
| 421 |
FILTER(v,0,1); |
| 422 |
FILTER(v,0,2); |
| 423 |
FILTER(v,0,3); |
| 424 |
FILTER(h,1,0); |
| 425 |
FILTER(h,1,1); |
| 426 |
FILTER(h,1,2); |
| 427 |
FILTER(h,1,3); |
| 428 |
} |
| 429 |
#undef FILTER
|
| 430 |
} |
| 431 |
} |
| 432 |
|
| 433 |
static int check_mv(H264Context *h, long b_idx, long bn_idx, int mvy_limit){ |
| 434 |
int v;
|
| 435 |
|
| 436 |
v= h->ref_cache[0][b_idx] != h->ref_cache[0][bn_idx]; |
| 437 |
if(!v && h->ref_cache[0][b_idx]!=-1) |
| 438 |
v= h->mv_cache[0][b_idx][0] - h->mv_cache[0][bn_idx][0] + 3 >= 7U | |
| 439 |
FFABS( h->mv_cache[0][b_idx][1] - h->mv_cache[0][bn_idx][1] ) >= mvy_limit; |
| 440 |
|
| 441 |
if(h->list_count==2){ |
| 442 |
if(!v)
|
| 443 |
v = h->ref_cache[1][b_idx] != h->ref_cache[1][bn_idx] | |
| 444 |
h->mv_cache[1][b_idx][0] - h->mv_cache[1][bn_idx][0] + 3 >= 7U | |
| 445 |
FFABS( h->mv_cache[1][b_idx][1] - h->mv_cache[1][bn_idx][1] ) >= mvy_limit; |
| 446 |
|
| 447 |
if(v){
|
| 448 |
if(h->ref_cache[0][b_idx] != h->ref_cache[1][bn_idx] | |
| 449 |
h->ref_cache[1][b_idx] != h->ref_cache[0][bn_idx]) |
| 450 |
return 1; |
| 451 |
return
|
| 452 |
h->mv_cache[0][b_idx][0] - h->mv_cache[1][bn_idx][0] + 3 >= 7U | |
| 453 |
FFABS( h->mv_cache[0][b_idx][1] - h->mv_cache[1][bn_idx][1] ) >= mvy_limit | |
| 454 |
h->mv_cache[1][b_idx][0] - h->mv_cache[0][bn_idx][0] + 3 >= 7U | |
| 455 |
FFABS( h->mv_cache[1][b_idx][1] - h->mv_cache[0][bn_idx][1] ) >= mvy_limit; |
| 456 |
} |
| 457 |
} |
| 458 |
|
| 459 |
return v;
|
| 460 |
} |
| 461 |
|
| 462 |
static av_always_inline void filter_mb_dir(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) { |
| 463 |
MpegEncContext * const s = &h->s;
|
| 464 |
int edge;
|
| 465 |
const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
| 466 |
const int mbm_type = dir == 0 ? h->left_type[0] : h->top_type; |
| 467 |
|
| 468 |
// how often to recheck mv-based bS when iterating between edges
|
| 469 |
static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1}, |
| 470 |
{0,3,1,1,3,3,3,3}};
|
| 471 |
const int mask_edge = mask_edge_tab[dir][(mb_type>>3)&7]; |
| 472 |
const int edges = mask_edge== 3 && !(h->cbp&15) ? 1 : 4; |
| 473 |
|
| 474 |
// how often to recheck mv-based bS when iterating along each edge
|
| 475 |
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); |
| 476 |
|
| 477 |
if(mbm_type && !first_vertical_edge_done){
|
| 478 |
|
| 479 |
if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) |
| 480 |
&& IS_INTERLACED(mbm_type&~mb_type) |
| 481 |
) {
|
| 482 |
// This is a special case in the norm where the filtering must
|
| 483 |
// be done twice (one each of the field) even if we are in a
|
| 484 |
// frame macroblock.
|
| 485 |
//
|
| 486 |
unsigned int tmp_linesize = 2 * linesize; |
| 487 |
unsigned int tmp_uvlinesize = 2 * uvlinesize; |
| 488 |
int mbn_xy = mb_xy - 2 * s->mb_stride; |
| 489 |
int j;
|
| 490 |
|
| 491 |
for(j=0; j<2; j++, mbn_xy += s->mb_stride){ |
| 492 |
DECLARE_ALIGNED(8, int16_t, bS)[4]; |
| 493 |
int qp;
|
| 494 |
if( IS_INTRA(mb_type|s->current_picture.mb_type[mbn_xy]) ) {
|
| 495 |
AV_WN64A(bS, 0x0003000300030003ULL);
|
| 496 |
} else {
|
| 497 |
if(!CABAC && IS_8x8DCT(s->current_picture.mb_type[mbn_xy])){
|
| 498 |
bS[0]= 1+((h->cbp_table[mbn_xy] & 4)||h->non_zero_count_cache[scan8[0]+0]); |
| 499 |
bS[1]= 1+((h->cbp_table[mbn_xy] & 4)||h->non_zero_count_cache[scan8[0]+1]); |
| 500 |
bS[2]= 1+((h->cbp_table[mbn_xy] & 8)||h->non_zero_count_cache[scan8[0]+2]); |
| 501 |
bS[3]= 1+((h->cbp_table[mbn_xy] & 8)||h->non_zero_count_cache[scan8[0]+3]); |
| 502 |
}else{
|
| 503 |
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy] + 4+3*8; |
| 504 |
int i;
|
| 505 |
for( i = 0; i < 4; i++ ) { |
| 506 |
bS[i] = 1 + !!(h->non_zero_count_cache[scan8[0]+i] | mbn_nnz[i]); |
| 507 |
} |
| 508 |
} |
| 509 |
} |
| 510 |
// Do not use s->qscale as luma quantizer because it has not the same
|
| 511 |
// value in IPCM macroblocks.
|
| 512 |
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; |
| 513 |
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
|
| 514 |
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
|
| 515 |
filter_mb_edgeh( &img_y[j*linesize], tmp_linesize, bS, qp, h ); |
| 516 |
filter_mb_edgech( &img_cb[j*uvlinesize], tmp_uvlinesize, bS, |
| 517 |
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1, h); |
| 518 |
filter_mb_edgech( &img_cr[j*uvlinesize], tmp_uvlinesize, bS, |
| 519 |
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1, h); |
| 520 |
} |
| 521 |
}else{
|
| 522 |
DECLARE_ALIGNED(8, int16_t, bS)[4]; |
| 523 |
int qp;
|
| 524 |
|
| 525 |
if( IS_INTRA(mb_type|mbm_type)) {
|
| 526 |
AV_WN64A(bS, 0x0003000300030003ULL);
|
| 527 |
if ( (!IS_INTERLACED(mb_type|mbm_type))
|
| 528 |
|| ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
|
| 529 |
) |
| 530 |
AV_WN64A(bS, 0x0004000400040004ULL);
|
| 531 |
} else {
|
| 532 |
int i;
|
| 533 |
int mv_done;
|
| 534 |
|
| 535 |
if( dir && FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbm_type)) {
|
| 536 |
AV_WN64A(bS, 0x0001000100010001ULL);
|
| 537 |
mv_done = 1;
|
| 538 |
} |
| 539 |
else if( mask_par0 && ((mbm_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
| 540 |
int b_idx= 8 + 4; |
| 541 |
int bn_idx= b_idx - (dir ? 8:1); |
| 542 |
|
| 543 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, 8 + 4, bn_idx, mvy_limit); |
| 544 |
mv_done = 1;
|
| 545 |
} |
| 546 |
else
|
| 547 |
mv_done = 0;
|
| 548 |
|
| 549 |
for( i = 0; i < 4; i++ ) { |
| 550 |
int x = dir == 0 ? 0 : i; |
| 551 |
int y = dir == 0 ? i : 0; |
| 552 |
int b_idx= 8 + 4 + x + 8*y; |
| 553 |
int bn_idx= b_idx - (dir ? 8:1); |
| 554 |
|
| 555 |
if( h->non_zero_count_cache[b_idx] |
|
| 556 |
h->non_zero_count_cache[bn_idx] ) {
|
| 557 |
bS[i] = 2;
|
| 558 |
} |
| 559 |
else if(!mv_done) |
| 560 |
{
|
| 561 |
bS[i] = check_mv(h, b_idx, bn_idx, mvy_limit); |
| 562 |
} |
| 563 |
} |
| 564 |
} |
| 565 |
|
| 566 |
/* Filter edge */
|
| 567 |
// Do not use s->qscale as luma quantizer because it has not the same
|
| 568 |
// value in IPCM macroblocks.
|
| 569 |
if(bS[0]+bS[1]+bS[2]+bS[3]){ |
| 570 |
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbm_xy] + 1 ) >> 1; |
| 571 |
//tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], s->current_picture.qscale_table[mbn_xy]);
|
| 572 |
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
|
| 573 |
//{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
|
| 574 |
if( dir == 0 ) { |
| 575 |
filter_mb_edgev( &img_y[0], linesize, bS, qp, h );
|
| 576 |
{
|
| 577 |
int qp= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbm_xy] ) + 1 ) >> 1; |
| 578 |
filter_mb_edgecv( &img_cb[0], uvlinesize, bS, qp, h);
|
| 579 |
if(h->pps.chroma_qp_diff)
|
| 580 |
qp= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbm_xy] ) + 1 ) >> 1; |
| 581 |
filter_mb_edgecv( &img_cr[0], uvlinesize, bS, qp, h);
|
| 582 |
} |
| 583 |
} else {
|
| 584 |
filter_mb_edgeh( &img_y[0], linesize, bS, qp, h );
|
| 585 |
{
|
| 586 |
int qp= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbm_xy] ) + 1 ) >> 1; |
| 587 |
filter_mb_edgech( &img_cb[0], uvlinesize, bS, qp, h);
|
| 588 |
if(h->pps.chroma_qp_diff)
|
| 589 |
qp= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbm_xy] ) + 1 ) >> 1; |
| 590 |
filter_mb_edgech( &img_cr[0], uvlinesize, bS, qp, h);
|
| 591 |
} |
| 592 |
} |
| 593 |
} |
| 594 |
} |
| 595 |
} |
| 596 |
|
| 597 |
/* Calculate bS */
|
| 598 |
for( edge = 1; edge < edges; edge++ ) { |
| 599 |
DECLARE_ALIGNED(8, int16_t, bS)[4]; |
| 600 |
int qp;
|
| 601 |
|
| 602 |
if( IS_8x8DCT(mb_type & (edge<<24)) ) // (edge&1) && IS_8x8DCT(mb_type) |
| 603 |
continue;
|
| 604 |
|
| 605 |
if( IS_INTRA(mb_type)) {
|
| 606 |
AV_WN64A(bS, 0x0003000300030003ULL);
|
| 607 |
} else {
|
| 608 |
int i;
|
| 609 |
int mv_done;
|
| 610 |
|
| 611 |
if( edge & mask_edge ) {
|
| 612 |
AV_ZERO64(bS); |
| 613 |
mv_done = 1;
|
| 614 |
} |
| 615 |
else if( mask_par0 ) { |
| 616 |
int b_idx= 8 + 4 + edge * (dir ? 8:1); |
| 617 |
int bn_idx= b_idx - (dir ? 8:1); |
| 618 |
|
| 619 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, b_idx, bn_idx, mvy_limit); |
| 620 |
mv_done = 1;
|
| 621 |
} |
| 622 |
else
|
| 623 |
mv_done = 0;
|
| 624 |
|
| 625 |
for( i = 0; i < 4; i++ ) { |
| 626 |
int x = dir == 0 ? edge : i; |
| 627 |
int y = dir == 0 ? i : edge; |
| 628 |
int b_idx= 8 + 4 + x + 8*y; |
| 629 |
int bn_idx= b_idx - (dir ? 8:1); |
| 630 |
|
| 631 |
if( h->non_zero_count_cache[b_idx] |
|
| 632 |
h->non_zero_count_cache[bn_idx] ) {
|
| 633 |
bS[i] = 2;
|
| 634 |
} |
| 635 |
else if(!mv_done) |
| 636 |
{
|
| 637 |
bS[i] = check_mv(h, b_idx, bn_idx, mvy_limit); |
| 638 |
} |
| 639 |
} |
| 640 |
|
| 641 |
if(bS[0]+bS[1]+bS[2]+bS[3] == 0) |
| 642 |
continue;
|
| 643 |
} |
| 644 |
|
| 645 |
/* Filter edge */
|
| 646 |
// Do not use s->qscale as luma quantizer because it has not the same
|
| 647 |
// value in IPCM macroblocks.
|
| 648 |
qp = s->current_picture.qscale_table[mb_xy]; |
| 649 |
//tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], s->current_picture.qscale_table[mbn_xy]);
|
| 650 |
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
|
| 651 |
//{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
|
| 652 |
if( dir == 0 ) { |
| 653 |
filter_mb_edgev( &img_y[4*edge*h->pixel_size], linesize, bS, qp, h );
|
| 654 |
if( (edge&1) == 0 ) { |
| 655 |
filter_mb_edgecv( &img_cb[2*edge*h->pixel_size], uvlinesize, bS, h->chroma_qp[0], h); |
| 656 |
filter_mb_edgecv( &img_cr[2*edge*h->pixel_size], uvlinesize, bS, h->chroma_qp[1], h); |
| 657 |
} |
| 658 |
} else {
|
| 659 |
filter_mb_edgeh( &img_y[4*edge*linesize], linesize, bS, qp, h );
|
| 660 |
if( (edge&1) == 0 ) { |
| 661 |
filter_mb_edgech( &img_cb[2*edge*uvlinesize], uvlinesize, bS, h->chroma_qp[0], h); |
| 662 |
filter_mb_edgech( &img_cr[2*edge*uvlinesize], uvlinesize, bS, h->chroma_qp[1], h); |
| 663 |
} |
| 664 |
} |
| 665 |
} |
| 666 |
} |
| 667 |
|
| 668 |
void ff_h264_filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { |
| 669 |
MpegEncContext * const s = &h->s;
|
| 670 |
const int mb_xy= mb_x + mb_y*s->mb_stride; |
| 671 |
const int mb_type = s->current_picture.mb_type[mb_xy]; |
| 672 |
const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4; |
| 673 |
int first_vertical_edge_done = 0; |
| 674 |
av_unused int dir;
|
| 675 |
|
| 676 |
if (FRAME_MBAFF
|
| 677 |
// and current and left pair do not have the same interlaced type
|
| 678 |
&& IS_INTERLACED(mb_type^h->left_type[0])
|
| 679 |
// and left mb is in available to us
|
| 680 |
&& h->left_type[0]) {
|
| 681 |
/* First vertical edge is different in MBAFF frames
|
| 682 |
* There are 8 different bS to compute and 2 different Qp
|
| 683 |
*/
|
| 684 |
DECLARE_ALIGNED(8, int16_t, bS)[8]; |
| 685 |
int qp[2]; |
| 686 |
int bqp[2]; |
| 687 |
int rqp[2]; |
| 688 |
int mb_qp, mbn0_qp, mbn1_qp;
|
| 689 |
int i;
|
| 690 |
first_vertical_edge_done = 1;
|
| 691 |
|
| 692 |
if( IS_INTRA(mb_type) ) {
|
| 693 |
AV_WN64A(&bS[0], 0x0004000400040004ULL); |
| 694 |
AV_WN64A(&bS[4], 0x0004000400040004ULL); |
| 695 |
} else {
|
| 696 |
static const uint8_t offset[2][2][8]={ |
| 697 |
{
|
| 698 |
{7+8*0, 7+8*0, 7+8*0, 7+8*0, 7+8*1, 7+8*1, 7+8*1, 7+8*1},
|
| 699 |
{7+8*2, 7+8*2, 7+8*2, 7+8*2, 7+8*3, 7+8*3, 7+8*3, 7+8*3},
|
| 700 |
},{
|
| 701 |
{7+8*0, 7+8*1, 7+8*2, 7+8*3, 7+8*0, 7+8*1, 7+8*2, 7+8*3},
|
| 702 |
{7+8*0, 7+8*1, 7+8*2, 7+8*3, 7+8*0, 7+8*1, 7+8*2, 7+8*3},
|
| 703 |
} |
| 704 |
}; |
| 705 |
const uint8_t *off= offset[MB_FIELD][mb_y&1]; |
| 706 |
for( i = 0; i < 8; i++ ) { |
| 707 |
int j= MB_FIELD ? i>>2 : i&1; |
| 708 |
int mbn_xy = h->left_mb_xy[j];
|
| 709 |
int mbn_type= h->left_type[j];
|
| 710 |
|
| 711 |
if( IS_INTRA( mbn_type ) )
|
| 712 |
bS[i] = 4;
|
| 713 |
else{
|
| 714 |
bS[i] = 1 + !!(h->non_zero_count_cache[12+8*(i>>1)] | |
| 715 |
((!h->pps.cabac && IS_8x8DCT(mbn_type)) ? |
| 716 |
(h->cbp_table[mbn_xy] & ((MB_FIELD ? (i&2) : (mb_y&1)) ? 8 : 2)) |
| 717 |
: |
| 718 |
h->non_zero_count[mbn_xy][ off[i] ])); |
| 719 |
} |
| 720 |
} |
| 721 |
} |
| 722 |
|
| 723 |
mb_qp = s->current_picture.qscale_table[mb_xy]; |
| 724 |
mbn0_qp = s->current_picture.qscale_table[h->left_mb_xy[0]];
|
| 725 |
mbn1_qp = s->current_picture.qscale_table[h->left_mb_xy[1]];
|
| 726 |
qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; |
| 727 |
bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) + |
| 728 |
get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1; |
| 729 |
rqp[0] = ( get_chroma_qp( h, 1, mb_qp ) + |
| 730 |
get_chroma_qp( h, 1, mbn0_qp ) + 1 ) >> 1; |
| 731 |
qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; |
| 732 |
bqp[1] = ( get_chroma_qp( h, 0, mb_qp ) + |
| 733 |
get_chroma_qp( h, 0, mbn1_qp ) + 1 ) >> 1; |
| 734 |
rqp[1] = ( get_chroma_qp( h, 1, mb_qp ) + |
| 735 |
get_chroma_qp( h, 1, mbn1_qp ) + 1 ) >> 1; |
| 736 |
|
| 737 |
/* Filter edge */
|
| 738 |
tprintf(s->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], bqp[0], bqp[1], rqp[0], rqp[1], linesize, uvlinesize); |
| 739 |
{ int i; for (i = 0; i < 8; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
|
| 740 |
if(MB_FIELD){
|
| 741 |
filter_mb_mbaff_edgev ( h, img_y , linesize, bS , 1, qp [0] ); |
| 742 |
filter_mb_mbaff_edgev ( h, img_y + 8* linesize, linesize, bS+4, 1, qp [1] ); |
| 743 |
filter_mb_mbaff_edgecv( h, img_cb, uvlinesize, bS , 1, bqp[0] ); |
| 744 |
filter_mb_mbaff_edgecv( h, img_cb + 4*uvlinesize, uvlinesize, bS+4, 1, bqp[1] ); |
| 745 |
filter_mb_mbaff_edgecv( h, img_cr, uvlinesize, bS , 1, rqp[0] ); |
| 746 |
filter_mb_mbaff_edgecv( h, img_cr + 4*uvlinesize, uvlinesize, bS+4, 1, rqp[1] ); |
| 747 |
}else{
|
| 748 |
filter_mb_mbaff_edgev ( h, img_y , 2* linesize, bS , 2, qp [0] ); |
| 749 |
filter_mb_mbaff_edgev ( h, img_y + linesize, 2* linesize, bS+1, 2, qp [1] ); |
| 750 |
filter_mb_mbaff_edgecv( h, img_cb, 2*uvlinesize, bS , 2, bqp[0] ); |
| 751 |
filter_mb_mbaff_edgecv( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1] ); |
| 752 |
filter_mb_mbaff_edgecv( h, img_cr, 2*uvlinesize, bS , 2, rqp[0] ); |
| 753 |
filter_mb_mbaff_edgecv( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1] ); |
| 754 |
} |
| 755 |
} |
| 756 |
|
| 757 |
#if CONFIG_SMALL
|
| 758 |
for( dir = 0; dir < 2; dir++ ) |
| 759 |
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, dir ? 0 : first_vertical_edge_done, dir);
|
| 760 |
#else
|
| 761 |
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, first_vertical_edge_done, 0);
|
| 762 |
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, 0, 1); |
| 763 |
#endif
|
| 764 |
} |