Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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