1/* 2 * RV40 decoder 3 * Copyright (c) 2007 Konstantin Shishkov 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 libavcodec/rv40.c 24 * RV40 decoder 25 */ 26 27#include "avcodec.h" 28#include "dsputil.h" 29#include "mpegvideo.h" 30#include "golomb.h" 31 32#include "rv34.h" 33#include "rv40vlc2.h" 34#include "rv40data.h" 35 36static VLC aic_top_vlc; 37static VLC aic_mode1_vlc[AIC_MODE1_NUM], aic_mode2_vlc[AIC_MODE2_NUM]; 38static VLC ptype_vlc[NUM_PTYPE_VLCS], btype_vlc[NUM_BTYPE_VLCS]; 39 40/** 41 * Initialize all tables. 42 */ 43static av_cold void rv40_init_tables(void) 44{ 45 int i; 46 47 init_vlc(&aic_top_vlc, AIC_TOP_BITS, AIC_TOP_SIZE, 48 rv40_aic_top_vlc_bits, 1, 1, 49 rv40_aic_top_vlc_codes, 1, 1, INIT_VLC_USE_STATIC); 50 for(i = 0; i < AIC_MODE1_NUM; i++){ 51 // Every tenth VLC table is empty 52 if((i % 10) == 9) continue; 53 init_vlc(&aic_mode1_vlc[i], AIC_MODE1_BITS, AIC_MODE1_SIZE, 54 aic_mode1_vlc_bits[i], 1, 1, 55 aic_mode1_vlc_codes[i], 1, 1, INIT_VLC_USE_STATIC); 56 } 57 for(i = 0; i < AIC_MODE2_NUM; i++){ 58 init_vlc(&aic_mode2_vlc[i], AIC_MODE2_BITS, AIC_MODE2_SIZE, 59 aic_mode2_vlc_bits[i], 1, 1, 60 aic_mode2_vlc_codes[i], 2, 2, INIT_VLC_USE_STATIC); 61 } 62 for(i = 0; i < NUM_PTYPE_VLCS; i++) 63 init_vlc_sparse(&ptype_vlc[i], PTYPE_VLC_BITS, PTYPE_VLC_SIZE, 64 ptype_vlc_bits[i], 1, 1, 65 ptype_vlc_codes[i], 1, 1, 66 ptype_vlc_syms, 1, 1, INIT_VLC_USE_STATIC); 67 for(i = 0; i < NUM_BTYPE_VLCS; i++) 68 init_vlc_sparse(&btype_vlc[i], BTYPE_VLC_BITS, BTYPE_VLC_SIZE, 69 btype_vlc_bits[i], 1, 1, 70 btype_vlc_codes[i], 1, 1, 71 btype_vlc_syms, 1, 1, INIT_VLC_USE_STATIC); 72} 73 74/** 75 * Get stored dimension from bitstream. 76 * 77 * If the width/height is the standard one then it's coded as a 3-bit index. 78 * Otherwise it is coded as escaped 8-bit portions. 79 */ 80static int get_dimension(GetBitContext *gb, const int *dim) 81{ 82 int t = get_bits(gb, 3); 83 int val = dim[t]; 84 if(val < 0) 85 val = dim[get_bits1(gb) - val]; 86 if(!val){ 87 do{ 88 t = get_bits(gb, 8); 89 val += t << 2; 90 }while(t == 0xFF); 91 } 92 return val; 93} 94 95/** 96 * Get encoded picture size - usually this is called from rv40_parse_slice_header. 97 */ 98static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h) 99{ 100 *w = get_dimension(gb, rv40_standard_widths); 101 *h = get_dimension(gb, rv40_standard_heights); 102} 103 104static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si) 105{ 106 int mb_bits; 107 int w = r->s.width, h = r->s.height; 108 int mb_size; 109 110 memset(si, 0, sizeof(SliceInfo)); 111 if(get_bits1(gb)) 112 return -1; 113 si->type = get_bits(gb, 2); 114 if(si->type == 1) si->type = 0; 115 si->quant = get_bits(gb, 5); 116 if(get_bits(gb, 2)) 117 return -1; 118 si->vlc_set = get_bits(gb, 2); 119 skip_bits1(gb); 120 si->pts = get_bits(gb, 13); 121 if(!si->type || !get_bits1(gb)) 122 rv40_parse_picture_size(gb, &w, &h); 123 if(avcodec_check_dimensions(r->s.avctx, w, h) < 0) 124 return -1; 125 si->width = w; 126 si->height = h; 127 mb_size = ((w + 15) >> 4) * ((h + 15) >> 4); 128 mb_bits = ff_rv34_get_start_offset(gb, mb_size); 129 si->start = get_bits(gb, mb_bits); 130 131 return 0; 132} 133 134/** 135 * Decode 4x4 intra types array. 136 */ 137static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst) 138{ 139 MpegEncContext *s = &r->s; 140 int i, j, k, v; 141 int A, B, C; 142 int pattern; 143 int8_t *ptr; 144 145 for(i = 0; i < 4; i++, dst += s->b4_stride){ 146 if(!i && s->first_slice_line){ 147 pattern = get_vlc2(gb, aic_top_vlc.table, AIC_TOP_BITS, 1); 148 dst[0] = (pattern >> 2) & 2; 149 dst[1] = (pattern >> 1) & 2; 150 dst[2] = pattern & 2; 151 dst[3] = (pattern << 1) & 2; 152 continue; 153 } 154 ptr = dst; 155 for(j = 0; j < 4; j++){ 156 /* Coefficients are read using VLC chosen by the prediction pattern 157 * The first one (used for retrieving a pair of coefficients) is 158 * constructed from the top, top right and left coefficients 159 * The second one (used for retrieving only one coefficient) is 160 * top + 10 * left. 161 */ 162 A = ptr[-s->b4_stride + 1]; // it won't be used for the last coefficient in a row 163 B = ptr[-s->b4_stride]; 164 C = ptr[-1]; 165 pattern = A + (B << 4) + (C << 8); 166 for(k = 0; k < MODE2_PATTERNS_NUM; k++) 167 if(pattern == rv40_aic_table_index[k]) 168 break; 169 if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding 2 coefficients 170 v = get_vlc2(gb, aic_mode2_vlc[k].table, AIC_MODE2_BITS, 2); 171 *ptr++ = v/9; 172 *ptr++ = v%9; 173 j++; 174 }else{ 175 if(B != -1 && C != -1) 176 v = get_vlc2(gb, aic_mode1_vlc[B + C*10].table, AIC_MODE1_BITS, 1); 177 else{ // tricky decoding 178 v = 0; 179 switch(C){ 180 case -1: // code 0 -> 1, 1 -> 0 181 if(B < 2) 182 v = get_bits1(gb) ^ 1; 183 break; 184 case 0: 185 case 2: // code 0 -> 2, 1 -> 0 186 v = (get_bits1(gb) ^ 1) << 1; 187 break; 188 } 189 } 190 *ptr++ = v; 191 } 192 } 193 } 194 return 0; 195} 196 197/** 198 * Decode macroblock information. 199 */ 200static int rv40_decode_mb_info(RV34DecContext *r) 201{ 202 MpegEncContext *s = &r->s; 203 GetBitContext *gb = &s->gb; 204 int q, i; 205 int prev_type = 0; 206 int mb_pos = s->mb_x + s->mb_y * s->mb_stride; 207 int blocks[RV34_MB_TYPES] = {0}; 208 int count = 0; 209 210 if(!r->s.mb_skip_run) 211 r->s.mb_skip_run = svq3_get_ue_golomb(gb) + 1; 212 213 if(--r->s.mb_skip_run) 214 return RV34_MB_SKIP; 215 216 if(r->avail_cache[5-1]) 217 blocks[r->mb_type[mb_pos - 1]]++; 218 if(r->avail_cache[5-4]){ 219 blocks[r->mb_type[mb_pos - s->mb_stride]]++; 220 if(r->avail_cache[5-2]) 221 blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++; 222 if(r->avail_cache[5-5]) 223 blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++; 224 } 225 226 for(i = 0; i < RV34_MB_TYPES; i++){ 227 if(blocks[i] > count){ 228 count = blocks[i]; 229 prev_type = i; 230 } 231 } 232 if(s->pict_type == FF_P_TYPE){ 233 prev_type = block_num_to_ptype_vlc_num[prev_type]; 234 q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1); 235 if(q < PBTYPE_ESCAPE) 236 return q; 237 q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1); 238 av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n"); 239 }else{ 240 prev_type = block_num_to_btype_vlc_num[prev_type]; 241 q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1); 242 if(q < PBTYPE_ESCAPE) 243 return q; 244 q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1); 245 av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n"); 246 } 247 return 0; 248} 249 250#define CLIP_SYMM(a, b) av_clip(a, -(b), b) 251/** 252 * weaker deblocking very similar to the one described in 4.4.2 of JVT-A003r1 253 */ 254static inline void rv40_weak_loop_filter(uint8_t *src, const int step, 255 const int filter_p1, const int filter_q1, 256 const int alpha, const int beta, 257 const int lim_p0q0, 258 const int lim_q1, const int lim_p1, 259 const int diff_p1p0, const int diff_q1q0, 260 const int diff_p1p2, const int diff_q1q2) 261{ 262 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; 263 int t, u, diff; 264 265 t = src[0*step] - src[-1*step]; 266 if(!t) 267 return; 268 u = (alpha * FFABS(t)) >> 7; 269 if(u > 3 - (filter_p1 && filter_q1)) 270 return; 271 272 t <<= 2; 273 if(filter_p1 && filter_q1) 274 t += src[-2*step] - src[1*step]; 275 diff = CLIP_SYMM((t + 4) >> 3, lim_p0q0); 276 src[-1*step] = cm[src[-1*step] + diff]; 277 src[ 0*step] = cm[src[ 0*step] - diff]; 278 if(FFABS(diff_p1p2) <= beta && filter_p1){ 279 t = (diff_p1p0 + diff_p1p2 - diff) >> 1; 280 src[-2*step] = cm[src[-2*step] - CLIP_SYMM(t, lim_p1)]; 281 } 282 if(FFABS(diff_q1q2) <= beta && filter_q1){ 283 t = (diff_q1q0 + diff_q1q2 + diff) >> 1; 284 src[ 1*step] = cm[src[ 1*step] - CLIP_SYMM(t, lim_q1)]; 285 } 286} 287 288static inline void rv40_adaptive_loop_filter(uint8_t *src, const int step, 289 const int stride, const int dmode, 290 const int lim_q1, const int lim_p1, 291 const int alpha, 292 const int beta, const int beta2, 293 const int chroma, const int edge) 294{ 295 int diff_p1p0[4], diff_q1q0[4], diff_p1p2[4], diff_q1q2[4]; 296 int sum_p1p0 = 0, sum_q1q0 = 0, sum_p1p2 = 0, sum_q1q2 = 0; 297 uint8_t *ptr; 298 int flag_strong0 = 1, flag_strong1 = 1; 299 int filter_p1, filter_q1; 300 int i; 301 int lims; 302 303 for(i = 0, ptr = src; i < 4; i++, ptr += stride){ 304 diff_p1p0[i] = ptr[-2*step] - ptr[-1*step]; 305 diff_q1q0[i] = ptr[ 1*step] - ptr[ 0*step]; 306 sum_p1p0 += diff_p1p0[i]; 307 sum_q1q0 += diff_q1q0[i]; 308 } 309 filter_p1 = FFABS(sum_p1p0) < (beta<<2); 310 filter_q1 = FFABS(sum_q1q0) < (beta<<2); 311 if(!filter_p1 && !filter_q1) 312 return; 313 314 for(i = 0, ptr = src; i < 4; i++, ptr += stride){ 315 diff_p1p2[i] = ptr[-2*step] - ptr[-3*step]; 316 diff_q1q2[i] = ptr[ 1*step] - ptr[ 2*step]; 317 sum_p1p2 += diff_p1p2[i]; 318 sum_q1q2 += diff_q1q2[i]; 319 } 320 321 if(edge){ 322 flag_strong0 = filter_p1 && (FFABS(sum_p1p2) < beta2); 323 flag_strong1 = filter_q1 && (FFABS(sum_q1q2) < beta2); 324 }else{ 325 flag_strong0 = flag_strong1 = 0; 326 } 327 328 lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1; 329 if(flag_strong0 && flag_strong1){ /* strong filtering */ 330 for(i = 0; i < 4; i++, src += stride){ 331 int sflag, p0, q0, p1, q1; 332 int t = src[0*step] - src[-1*step]; 333 334 if(!t) continue; 335 sflag = (alpha * FFABS(t)) >> 7; 336 if(sflag > 1) continue; 337 338 p0 = (25*src[-3*step] + 26*src[-2*step] 339 + 26*src[-1*step] 340 + 26*src[ 0*step] + 25*src[ 1*step] + rv40_dither_l[dmode + i]) >> 7; 341 q0 = (25*src[-2*step] + 26*src[-1*step] 342 + 26*src[ 0*step] 343 + 26*src[ 1*step] + 25*src[ 2*step] + rv40_dither_r[dmode + i]) >> 7; 344 if(sflag){ 345 p0 = av_clip(p0, src[-1*step] - lims, src[-1*step] + lims); 346 q0 = av_clip(q0, src[ 0*step] - lims, src[ 0*step] + lims); 347 } 348 p1 = (25*src[-4*step] + 26*src[-3*step] 349 + 26*src[-2*step] 350 + 26*p0 + 25*src[ 0*step] + rv40_dither_l[dmode + i]) >> 7; 351 q1 = (25*src[-1*step] + 26*q0 352 + 26*src[ 1*step] 353 + 26*src[ 2*step] + 25*src[ 3*step] + rv40_dither_r[dmode + i]) >> 7; 354 if(sflag){ 355 p1 = av_clip(p1, src[-2*step] - lims, src[-2*step] + lims); 356 q1 = av_clip(q1, src[ 1*step] - lims, src[ 1*step] + lims); 357 } 358 src[-2*step] = p1; 359 src[-1*step] = p0; 360 src[ 0*step] = q0; 361 src[ 1*step] = q1; 362 if(!chroma){ 363 src[-3*step] = (25*src[-1*step] + 26*src[-2*step] + 51*src[-3*step] + 26*src[-4*step] + 64) >> 7; 364 src[ 2*step] = (25*src[ 0*step] + 26*src[ 1*step] + 51*src[ 2*step] + 26*src[ 3*step] + 64) >> 7; 365 } 366 } 367 }else if(filter_p1 && filter_q1){ 368 for(i = 0; i < 4; i++, src += stride) 369 rv40_weak_loop_filter(src, step, 1, 1, alpha, beta, lims, lim_q1, lim_p1, 370 diff_p1p0[i], diff_q1q0[i], diff_p1p2[i], diff_q1q2[i]); 371 }else{ 372 for(i = 0; i < 4; i++, src += stride) 373 rv40_weak_loop_filter(src, step, filter_p1, filter_q1, 374 alpha, beta, lims>>1, lim_q1>>1, lim_p1>>1, 375 diff_p1p0[i], diff_q1q0[i], diff_p1p2[i], diff_q1q2[i]); 376 } 377} 378 379static void rv40_v_loop_filter(uint8_t *src, int stride, int dmode, 380 int lim_q1, int lim_p1, 381 int alpha, int beta, int beta2, int chroma, int edge){ 382 rv40_adaptive_loop_filter(src, 1, stride, dmode, lim_q1, lim_p1, 383 alpha, beta, beta2, chroma, edge); 384} 385static void rv40_h_loop_filter(uint8_t *src, int stride, int dmode, 386 int lim_q1, int lim_p1, 387 int alpha, int beta, int beta2, int chroma, int edge){ 388 rv40_adaptive_loop_filter(src, stride, 1, dmode, lim_q1, lim_p1, 389 alpha, beta, beta2, chroma, edge); 390} 391 392enum RV40BlockPos{ 393 POS_CUR, 394 POS_TOP, 395 POS_LEFT, 396 POS_BOTTOM, 397}; 398 399#define MASK_CUR 0x0001 400#define MASK_RIGHT 0x0008 401#define MASK_BOTTOM 0x0010 402#define MASK_TOP 0x1000 403#define MASK_Y_TOP_ROW 0x000F 404#define MASK_Y_LAST_ROW 0xF000 405#define MASK_Y_LEFT_COL 0x1111 406#define MASK_Y_RIGHT_COL 0x8888 407#define MASK_C_TOP_ROW 0x0003 408#define MASK_C_LAST_ROW 0x000C 409#define MASK_C_LEFT_COL 0x0005 410#define MASK_C_RIGHT_COL 0x000A 411 412static const int neighbour_offs_x[4] = { 0, 0, -1, 0 }; 413static const int neighbour_offs_y[4] = { 0, -1, 0, 1 }; 414 415/** 416 * RV40 loop filtering function 417 */ 418static void rv40_loop_filter(RV34DecContext *r, int row) 419{ 420 MpegEncContext *s = &r->s; 421 int mb_pos, mb_x; 422 int i, j, k; 423 uint8_t *Y, *C; 424 int alpha, beta, betaY, betaC; 425 int q; 426 int mbtype[4]; ///< current macroblock and its neighbours types 427 /** 428 * flags indicating that macroblock can be filtered with strong filter 429 * it is set only for intra coded MB and MB with DCs coded separately 430 */ 431 int mb_strong[4]; 432 int clip[4]; ///< MB filter clipping value calculated from filtering strength 433 /** 434 * coded block patterns for luma part of current macroblock and its neighbours 435 * Format: 436 * LSB corresponds to the top left block, 437 * each nibble represents one row of subblocks. 438 */ 439 int cbp[4]; 440 /** 441 * coded block patterns for chroma part of current macroblock and its neighbours 442 * Format is the same as for luma with two subblocks in a row. 443 */ 444 int uvcbp[4][2]; 445 /** 446 * This mask represents the pattern of luma subblocks that should be filtered 447 * in addition to the coded ones because because they lie at the edge of 448 * 8x8 block with different enough motion vectors 449 */ 450 int mvmasks[4]; 451 452 mb_pos = row * s->mb_stride; 453 for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){ 454 int mbtype = s->current_picture_ptr->mb_type[mb_pos]; 455 if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype)) 456 r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF; 457 if(IS_INTRA(mbtype)) 458 r->cbp_chroma[mb_pos] = 0xFF; 459 } 460 mb_pos = row * s->mb_stride; 461 for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){ 462 int y_h_deblock, y_v_deblock; 463 int c_v_deblock[2], c_h_deblock[2]; 464 int clip_left; 465 int avail[4]; 466 int y_to_deblock, c_to_deblock[2]; 467 468 q = s->current_picture_ptr->qscale_table[mb_pos]; 469 alpha = rv40_alpha_tab[q]; 470 beta = rv40_beta_tab [q]; 471 betaY = betaC = beta * 3; 472 if(s->width * s->height <= 176*144) 473 betaY += beta; 474 475 avail[0] = 1; 476 avail[1] = row; 477 avail[2] = mb_x; 478 avail[3] = row < s->mb_height - 1; 479 for(i = 0; i < 4; i++){ 480 if(avail[i]){ 481 int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride; 482 mvmasks[i] = r->deblock_coefs[pos]; 483 mbtype [i] = s->current_picture_ptr->mb_type[pos]; 484 cbp [i] = r->cbp_luma[pos]; 485 uvcbp[i][0] = r->cbp_chroma[pos] & 0xF; 486 uvcbp[i][1] = r->cbp_chroma[pos] >> 4; 487 }else{ 488 mvmasks[i] = 0; 489 mbtype [i] = mbtype[0]; 490 cbp [i] = 0; 491 uvcbp[i][0] = uvcbp[i][1] = 0; 492 } 493 mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]); 494 clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q]; 495 } 496 y_to_deblock = mvmasks[POS_CUR] 497 | (mvmasks[POS_BOTTOM] << 16); 498 /* This pattern contains bits signalling that horizontal edges of 499 * the current block can be filtered. 500 * That happens when either of adjacent subblocks is coded or lies on 501 * the edge of 8x8 blocks with motion vectors differing by more than 502 * 3/4 pel in any component (any edge orientation for some reason). 503 */ 504 y_h_deblock = y_to_deblock 505 | ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW) 506 | ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12); 507 /* This pattern contains bits signalling that vertical edges of 508 * the current block can be filtered. 509 * That happens when either of adjacent subblocks is coded or lies on 510 * the edge of 8x8 blocks with motion vectors differing by more than 511 * 3/4 pel in any component (any edge orientation for some reason). 512 */ 513 y_v_deblock = y_to_deblock 514 | ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL) 515 | ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3); 516 if(!mb_x) 517 y_v_deblock &= ~MASK_Y_LEFT_COL; 518 if(!row) 519 y_h_deblock &= ~MASK_Y_TOP_ROW; 520 if(row == s->mb_height - 1 || (mb_strong[POS_CUR] || mb_strong[POS_BOTTOM])) 521 y_h_deblock &= ~(MASK_Y_TOP_ROW << 16); 522 /* Calculating chroma patterns is similar and easier since there is 523 * no motion vector pattern for them. 524 */ 525 for(i = 0; i < 2; i++){ 526 c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i]; 527 c_v_deblock[i] = c_to_deblock[i] 528 | ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL) 529 | ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1); 530 c_h_deblock[i] = c_to_deblock[i] 531 | ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2) 532 | (uvcbp[POS_CUR][i] << 2); 533 if(!mb_x) 534 c_v_deblock[i] &= ~MASK_C_LEFT_COL; 535 if(!row) 536 c_h_deblock[i] &= ~MASK_C_TOP_ROW; 537 if(row == s->mb_height - 1 || mb_strong[POS_CUR] || mb_strong[POS_BOTTOM]) 538 c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4); 539 } 540 541 for(j = 0; j < 16; j += 4){ 542 Y = s->current_picture_ptr->data[0] + mb_x*16 + (row*16 + j) * s->linesize; 543 for(i = 0; i < 4; i++, Y += 4){ 544 int ij = i + j; 545 int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0; 546 int dither = j ? ij : i*4; 547 548 // if bottom block is coded then we can filter its top edge 549 // (or bottom edge of this block, which is the same) 550 if(y_h_deblock & (MASK_BOTTOM << ij)){ 551 rv40_h_loop_filter(Y+4*s->linesize, s->linesize, dither, 552 y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0, 553 clip_cur, 554 alpha, beta, betaY, 0, 0); 555 } 556 // filter left block edge in ordinary mode (with low filtering strength) 557 if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] || mb_strong[POS_LEFT]))){ 558 if(!i) 559 clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0; 560 else 561 clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0; 562 rv40_v_loop_filter(Y, s->linesize, dither, 563 clip_cur, 564 clip_left, 565 alpha, beta, betaY, 0, 0); 566 } 567 // filter top edge of the current macroblock when filtering strength is high 568 if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] || mb_strong[POS_TOP])){ 569 rv40_h_loop_filter(Y, s->linesize, dither, 570 clip_cur, 571 mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0, 572 alpha, beta, betaY, 0, 1); 573 } 574 // filter left block edge in edge mode (with high filtering strength) 575 if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] || mb_strong[POS_LEFT])){ 576 clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0; 577 rv40_v_loop_filter(Y, s->linesize, dither, 578 clip_cur, 579 clip_left, 580 alpha, beta, betaY, 0, 1); 581 } 582 } 583 } 584 for(k = 0; k < 2; k++){ 585 for(j = 0; j < 2; j++){ 586 C = s->current_picture_ptr->data[k+1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize; 587 for(i = 0; i < 2; i++, C += 4){ 588 int ij = i + j*2; 589 int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0; 590 if(c_h_deblock[k] & (MASK_CUR << (ij+2))){ 591 int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0; 592 rv40_h_loop_filter(C+4*s->uvlinesize, s->uvlinesize, i*8, 593 clip_bot, 594 clip_cur, 595 alpha, beta, betaC, 1, 0); 596 } 597 if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] || mb_strong[POS_LEFT]))){ 598 if(!i) 599 clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0; 600 else 601 clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0; 602 rv40_v_loop_filter(C, s->uvlinesize, j*8, 603 clip_cur, 604 clip_left, 605 alpha, beta, betaC, 1, 0); 606 } 607 if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] || mb_strong[POS_TOP])){ 608 int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0; 609 rv40_h_loop_filter(C, s->uvlinesize, i*8, 610 clip_cur, 611 clip_top, 612 alpha, beta, betaC, 1, 1); 613 } 614 if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] || mb_strong[POS_LEFT])){ 615 clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0; 616 rv40_v_loop_filter(C, s->uvlinesize, j*8, 617 clip_cur, 618 clip_left, 619 alpha, beta, betaC, 1, 1); 620 } 621 } 622 } 623 } 624 } 625} 626 627/** 628 * Initialize decoder. 629 */ 630static av_cold int rv40_decode_init(AVCodecContext *avctx) 631{ 632 RV34DecContext *r = avctx->priv_data; 633 634 r->rv30 = 0; 635 ff_rv34_decode_init(avctx); 636 if(!aic_top_vlc.bits) 637 rv40_init_tables(); 638 r->parse_slice_header = rv40_parse_slice_header; 639 r->decode_intra_types = rv40_decode_intra_types; 640 r->decode_mb_info = rv40_decode_mb_info; 641 r->loop_filter = rv40_loop_filter; 642 r->luma_dc_quant_i = rv40_luma_dc_quant[0]; 643 r->luma_dc_quant_p = rv40_luma_dc_quant[1]; 644 return 0; 645} 646 647AVCodec rv40_decoder = { 648 "rv40", 649 CODEC_TYPE_VIDEO, 650 CODEC_ID_RV40, 651 sizeof(RV34DecContext), 652 rv40_decode_init, 653 NULL, 654 ff_rv34_decode_end, 655 ff_rv34_decode_frame, 656 CODEC_CAP_DR1 | CODEC_CAP_DELAY, 657 .flush = ff_mpeg_flush, 658 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"), 659 .pix_fmts= ff_pixfmt_list_420, 660}; 661