3 * Copyright (c) 2007 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/rv40.c
29 #include "mpegvideo.h"
36 static VLC aic_top_vlc
;
37 static VLC aic_mode1_vlc
[AIC_MODE1_NUM
], aic_mode2_vlc
[AIC_MODE2_NUM
];
38 static VLC ptype_vlc
[NUM_PTYPE_VLCS
], btype_vlc
[NUM_BTYPE_VLCS
];
41 * Initialize all tables.
43 static av_cold
void rv40_init_tables(void)
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
);
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
);
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
);
75 * Get stored dimension from bitstream.
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.
80 static int get_dimension(GetBitContext
*gb
, const int *dim
)
82 int t
= get_bits(gb
, 3);
85 val
= dim
[get_bits1(gb
) - val
];
96 * Get encoded picture size - usually this is called from rv40_parse_slice_header.
98 static void rv40_parse_picture_size(GetBitContext
*gb
, int *w
, int *h
)
100 *w
= get_dimension(gb
, rv40_standard_widths
);
101 *h
= get_dimension(gb
, rv40_standard_heights
);
104 static int rv40_parse_slice_header(RV34DecContext
*r
, GetBitContext
*gb
, SliceInfo
*si
)
107 int w
= r
->s
.width
, h
= r
->s
.height
;
110 memset(si
, 0, sizeof(SliceInfo
));
113 si
->type
= get_bits(gb
, 2);
114 if(si
->type
== 1) si
->type
= 0;
115 si
->quant
= get_bits(gb
, 5);
118 si
->vlc_set
= get_bits(gb
, 2);
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)
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
);
135 * Decode 4x4 intra types array.
137 static int rv40_decode_intra_types(RV34DecContext
*r
, GetBitContext
*gb
, int8_t *dst
)
139 MpegEncContext
*s
= &r
->s
;
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;
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
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
];
165 pattern
= A
+ (B
<< 4) + (C
<< 8);
166 for(k
= 0; k
< MODE2_PATTERNS_NUM
; k
++)
167 if(pattern
== rv40_aic_table_index
[k
])
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);
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
180 case -1: // code 0 -> 1, 1 -> 0
182 v
= get_bits1(gb
) ^ 1;
185 case 2: // code 0 -> 2, 1 -> 0
186 v
= (get_bits1(gb
) ^ 1) << 1;
198 * Decode macroblock information.
200 static int rv40_decode_mb_info(RV34DecContext
*r
)
202 MpegEncContext
*s
= &r
->s
;
203 GetBitContext
*gb
= &s
->gb
;
206 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
207 int blocks
[RV34_MB_TYPES
] = {0};
210 if(!r
->s
.mb_skip_run
)
211 r
->s
.mb_skip_run
= svq3_get_ue_golomb(gb
) + 1;
213 if(--r
->s
.mb_skip_run
)
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]]++;
226 for(i
= 0; i
< RV34_MB_TYPES
; i
++){
227 if(blocks
[i
] > count
){
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
)
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");
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
)
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");
250 #define CLIP_SYMM(a, b) av_clip(a, -(b), b)
252 * weaker deblocking very similar to the one described in 4.4.2 of JVT-A003r1
254 static 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
,
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
)
262 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
265 t
= src
[0*step
] - src
[-1*step
];
268 u
= (alpha
* FFABS(t
)) >> 7;
269 if(u
> 3 - (filter_p1
&& filter_q1
))
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
)];
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
)];
288 static 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
,
292 const int beta
, const int beta2
,
293 const int chroma
, const int edge
)
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;
298 int flag_strong0
= 1, flag_strong1
= 1;
299 int filter_p1
, filter_q1
;
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
];
309 filter_p1
= FFABS(sum_p1p0
) < (beta
<<2);
310 filter_q1
= FFABS(sum_q1q0
) < (beta
<<2);
311 if(!filter_p1
&& !filter_q1
)
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
];
322 flag_strong0
= filter_p1
&& (FFABS(sum_p1p2
) < beta2
);
323 flag_strong1
= filter_q1
&& (FFABS(sum_q1q2
) < beta2
);
325 flag_strong0
= flag_strong1
= 0;
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
];
335 sflag
= (alpha
* FFABS(t
)) >> 7;
336 if(sflag
> 1) continue;
338 p0
= (25*src
[-3*step
] + 26*src
[-2*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
]
343 + 26*src
[ 1*step
] + 25*src
[ 2*step
] + rv40_dither_r
[dmode
+ i
]) >> 7;
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
);
348 p1
= (25*src
[-4*step
] + 26*src
[-3*step
]
350 + 26*p0
+ 25*src
[ 0*step
] + rv40_dither_l
[dmode
+ i
]) >> 7;
351 q1
= (25*src
[-1*step
] + 26*q0
353 + 26*src
[ 2*step
] + 25*src
[ 3*step
] + rv40_dither_r
[dmode
+ i
]) >> 7;
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
);
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;
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
]);
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
]);
379 static 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
);
385 static 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
);
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
412 static const int neighbour_offs_x
[4] = { 0, 0, -1, 0 };
413 static const int neighbour_offs_y
[4] = { 0, -1, 0, 1 };
416 * RV40 loop filtering function
418 static void rv40_loop_filter(RV34DecContext
*r
, int row
)
420 MpegEncContext
*s
= &r
->s
;
424 int alpha
, beta
, betaY
, betaC
;
426 int mbtype
[4]; ///< current macroblock and its neighbours types
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
432 int clip
[4]; ///< MB filter clipping value calculated from filtering strength
434 * coded block patterns for luma part of current macroblock and its neighbours
436 * LSB corresponds to the top left block,
437 * each nibble represents one row of subblocks.
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.
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
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;
458 r
->cbp_chroma
[mb_pos
] = 0xFF;
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];
466 int y_to_deblock
, c_to_deblock
[2];
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)
478 avail
[3] = row
< s
->mb_height
- 1;
479 for(i
= 0; i
< 4; 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;
489 mbtype
[i
] = mbtype
[0];
491 uvcbp
[i
][0] = uvcbp
[i
][1] = 0;
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
];
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).
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).
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);
517 y_v_deblock
&= ~MASK_Y_LEFT_COL
;
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.
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);
534 c_v_deblock
[i
] &= ~MASK_C_LEFT_COL
;
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);
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){
545 int clip_cur
= y_to_deblock
& (MASK_CUR
<< ij
) ? clip
[POS_CUR
] : 0;
546 int dither
= j
? ij
: i
*4;
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,
554 alpha
, beta
, betaY
, 0, 0);
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
]))){
559 clip_left
= mvmasks
[POS_LEFT
] & (MASK_RIGHT
<< j
) ? clip
[POS_LEFT
] : 0;
561 clip_left
= y_to_deblock
& (MASK_CUR
<< (ij
-1)) ? clip
[POS_CUR
] : 0;
562 rv40_v_loop_filter(Y
, s
->linesize
, dither
,
565 alpha
, beta
, betaY
, 0, 0);
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
,
571 mvmasks
[POS_TOP
] & (MASK_TOP
<< i
) ? clip
[POS_TOP
] : 0,
572 alpha
, beta
, betaY
, 0, 1);
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
,
580 alpha
, beta
, betaY
, 0, 1);
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){
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,
595 alpha
, beta
, betaC
, 1, 0);
597 if((c_v_deblock
[k
] & (MASK_CUR
<< ij
)) && (i
|| !(mb_strong
[POS_CUR
] || mb_strong
[POS_LEFT
]))){
599 clip_left
= uvcbp
[POS_LEFT
][k
] & (MASK_CUR
<< (2*j
+1)) ? clip
[POS_LEFT
] : 0;
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,
605 alpha
, beta
, betaC
, 1, 0);
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,
612 alpha
, beta
, betaC
, 1, 1);
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,
619 alpha
, beta
, betaC
, 1, 1);
628 * Initialize decoder.
630 static av_cold
int rv40_decode_init(AVCodecContext
*avctx
)
632 RV34DecContext
*r
= avctx
->priv_data
;
635 ff_rv34_decode_init(avctx
);
636 if(!aic_top_vlc
.bits
)
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];
647 AVCodec rv40_decoder
= {
651 sizeof(RV34DecContext
),
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
,