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