开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
simple_idct.c
资源名称：ffh264lib_0510.zip　[点击查看]
上传用户：jylinhe
上传日期：2022-07-11
资源大小：334k
文件大小：16k
源码类别：

多媒体编程

开发平台：

Visual C++

simple_idct.c：源码内容
  1. /*
  2.  * Simple IDCT
  3.  *
  4.  * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  23. /**
  24.  * @file simple_idct.c
  25.  * simpleidct in C.
  26.  */
  28. /*
  29.   based upon some outcommented c code from mpeg2dec (idct_mmx.c
  30.   written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
  31.  */
  32. #include "dsputil.h"
  33. //#include "internal.h"
  34. //#include "integer.h"
  35. #include "mathops.h"
  36. //#include "simple_idct.h"
  38. #if 0
  39. #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
  40. #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
  41. #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
  42. #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
  43. #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
  44. #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
  45. #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
  46. #define ROW_SHIFT 8
  47. #define COL_SHIFT 17
  48. #else
  49. #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  50. #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  51. #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  52. #define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  53. #define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  54. #define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  55. #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  56. #define ROW_SHIFT 11
  57. #define COL_SHIFT 20 // 6
  58. #endif
  60. static inline void idctRowCondDC (DCTELEM * row)
  61. {
  62.         int a0, a1, a2, a3, b0, b1, b2, b3;
  63. #ifdef HAVE_FAST_64BIT
  64.         uint64_t temp;
  65. #else
  66.         uint32_t temp;
  67. #endif
  69. #ifdef HAVE_FAST_64BIT
  70. #ifdef WORDS_BIGENDIAN
  71. #define ROW0_MASK 0xffff000000000000LL
  72. #else
  73. #define ROW0_MASK 0xffffLL
  74. #endif
  75.         if(sizeof(DCTELEM)==2){
  76.             if ( ((((uint64_t *)row)[0] & ~ROW0_MASK) |
  77.                   ((uint64_t *)row)[1]) == 0) {
  78.                 temp = (row[0] << 3) & 0xffff;
  79.                 temp += temp << 16;
  80.                 temp += temp << 32;
  81.                 ((uint64_t *)row)[0] = temp;
  82.                 ((uint64_t *)row)[1] = temp;
  83.                 return;
  84.             }
  85.         }else{
  86.             if (!(row[1]|row[2]|row[3]|row[4]|row[5]|row[6]|row[7])) {
  87.                 row[0]=row[1]=row[2]=row[3]=row[4]=row[5]=row[6]=row[7]= row[0] << 3;
  88.                 return;
  89.             }
  90.         }
  91. #else
  92.         if(sizeof(DCTELEM)==2){
  93.             if (!(((uint32_t*)row)[1] |
  94.                   ((uint32_t*)row)[2] |
  95.                   ((uint32_t*)row)[3] |
  96.                   row[1])) {
  97.                 temp = (row[0] << 3) & 0xffff;
  98.                 temp += temp << 16;
  99.                 ((uint32_t*)row)[0]=((uint32_t*)row)[1] =
  100.                 ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
  101.                 return;
  102.             }
  103.         }else{
  104.             if (!(row[1]|row[2]|row[3]|row[4]|row[5]|row[6]|row[7])) {
  105.                 row[0]=row[1]=row[2]=row[3]=row[4]=row[5]=row[6]=row[7]= row[0] << 3;
  106.                 return;
  107.             }
  108.         }
  109. #endif
  111.         a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
  112.         a1 = a0;
  113.         a2 = a0;
  114.         a3 = a0;
  116.         /* no need to optimize : gcc does it */
  117.         a0 += W2 * row[2];
  118.         a1 += W6 * row[2];
  119.         a2 -= W6 * row[2];
  120.         a3 -= W2 * row[2];
  122.         b0 = MUL16(W1, row[1]);
  123.         MAC16(b0, W3, row[3]);
  124.         b1 = MUL16(W3, row[1]);
  125.         MAC16(b1, -W7, row[3]);
  126.         b2 = MUL16(W5, row[1]);
  127.         MAC16(b2, -W1, row[3]);
  128.         b3 = MUL16(W7, row[1]);
  129.         MAC16(b3, -W5, row[3]);
  131. #ifdef HAVE_FAST_64BIT
  132.         temp = ((uint64_t*)row)[1];
  133. #else
  134.         temp = ((uint32_t*)row)[2] | ((uint32_t*)row)[3];
  135. #endif
  136.         if (temp != 0) {
  137.             a0 += W4*row[4] + W6*row[6];
  138.             a1 += - W4*row[4] - W2*row[6];
  139.             a2 += - W4*row[4] + W2*row[6];
  140.             a3 += W4*row[4] - W6*row[6];
  142.             MAC16(b0, W5, row[5]);
  143.             MAC16(b0, W7, row[7]);
  145.             MAC16(b1, -W1, row[5]);
  146.             MAC16(b1, -W5, row[7]);
  148.             MAC16(b2, W7, row[5]);
  149.             MAC16(b2, W3, row[7]);
  151.             MAC16(b3, W3, row[5]);
  152.             MAC16(b3, -W1, row[7]);
  153.         }
  155.         row[0] = (a0 + b0) >> ROW_SHIFT;
  156.         row[7] = (a0 - b0) >> ROW_SHIFT;
  157.         row[1] = (a1 + b1) >> ROW_SHIFT;
  158.         row[6] = (a1 - b1) >> ROW_SHIFT;
  159.         row[2] = (a2 + b2) >> ROW_SHIFT;
  160.         row[5] = (a2 - b2) >> ROW_SHIFT;
  161.         row[3] = (a3 + b3) >> ROW_SHIFT;
  162.         row[4] = (a3 - b3) >> ROW_SHIFT;
  163. }
  165. static inline void idctSparseColPut (uint8_t *dest, int line_size,
  166.                                      DCTELEM * col)
  167. {
  168.         int a0, a1, a2, a3, b0, b1, b2, b3;
  169.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  171.         /* XXX: I did that only to give same values as previous code */
  172.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
  173.         a1 = a0;
  174.         a2 = a0;
  175.         a3 = a0;
  177.         a0 +=  + W2*col[8*2];
  178.         a1 +=  + W6*col[8*2];
  179.         a2 +=  - W6*col[8*2];
  180.         a3 +=  - W2*col[8*2];
  182.         b0 = MUL16(W1, col[8*1]);
  183.         b1 = MUL16(W3, col[8*1]);
  184.         b2 = MUL16(W5, col[8*1]);
  185.         b3 = MUL16(W7, col[8*1]);
  187.         MAC16(b0, + W3, col[8*3]);
  188.         MAC16(b1, - W7, col[8*3]);
  189.         MAC16(b2, - W1, col[8*3]);
  190.         MAC16(b3, - W5, col[8*3]);
  192.         if(col[8*4]){
  193.             a0 += + W4*col[8*4];
  194.             a1 += - W4*col[8*4];
  195.             a2 += - W4*col[8*4];
  196.             a3 += + W4*col[8*4];
  197.         }
  199.         if (col[8*5]) {
  200.             MAC16(b0, + W5, col[8*5]);
  201.             MAC16(b1, - W1, col[8*5]);
  202.             MAC16(b2, + W7, col[8*5]);
  203.             MAC16(b3, + W3, col[8*5]);
  204.         }
  206.         if(col[8*6]){
  207.             a0 += + W6*col[8*6];
  208.             a1 += - W2*col[8*6];
  209.             a2 += + W2*col[8*6];
  210.             a3 += - W6*col[8*6];
  211.         }
  213.         if (col[8*7]) {
  214.             MAC16(b0, + W7, col[8*7]);
  215.             MAC16(b1, - W5, col[8*7]);
  216.             MAC16(b2, + W3, col[8*7]);
  217.             MAC16(b3, - W1, col[8*7]);
  218.         }
  220.         dest[0] = cm[(a0 + b0) >> COL_SHIFT];
  221.         dest += line_size;
  222.         dest[0] = cm[(a1 + b1) >> COL_SHIFT];
  223.         dest += line_size;
  224.         dest[0] = cm[(a2 + b2) >> COL_SHIFT];
  225.         dest += line_size;
  226.         dest[0] = cm[(a3 + b3) >> COL_SHIFT];
  227.         dest += line_size;
  228.         dest[0] = cm[(a3 - b3) >> COL_SHIFT];
  229.         dest += line_size;
  230.         dest[0] = cm[(a2 - b2) >> COL_SHIFT];
  231.         dest += line_size;
  232.         dest[0] = cm[(a1 - b1) >> COL_SHIFT];
  233.         dest += line_size;
  234.         dest[0] = cm[(a0 - b0) >> COL_SHIFT];
  235. }
  237. static inline void idctSparseColAdd (uint8_t *dest, int line_size,
  238.                                      DCTELEM * col)
  239. {
  240.         int a0, a1, a2, a3, b0, b1, b2, b3;
  241.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  243.         /* XXX: I did that only to give same values as previous code */
  244.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
  245.         a1 = a0;
  246.         a2 = a0;
  247.         a3 = a0;
  249.         a0 +=  + W2*col[8*2];
  250.         a1 +=  + W6*col[8*2];
  251.         a2 +=  - W6*col[8*2];
  252.         a3 +=  - W2*col[8*2];
  254.         b0 = MUL16(W1, col[8*1]);
  255.         b1 = MUL16(W3, col[8*1]);
  256.         b2 = MUL16(W5, col[8*1]);
  257.         b3 = MUL16(W7, col[8*1]);
  259.         MAC16(b0, + W3, col[8*3]);
  260.         MAC16(b1, - W7, col[8*3]);
  261.         MAC16(b2, - W1, col[8*3]);
  262.         MAC16(b3, - W5, col[8*3]);
  264.         if(col[8*4]){
  265.             a0 += + W4*col[8*4];
  266.             a1 += - W4*col[8*4];
  267.             a2 += - W4*col[8*4];
  268.             a3 += + W4*col[8*4];
  269.         }
  271.         if (col[8*5]) {
  272.             MAC16(b0, + W5, col[8*5]);
  273.             MAC16(b1, - W1, col[8*5]);
  274.             MAC16(b2, + W7, col[8*5]);
  275.             MAC16(b3, + W3, col[8*5]);
  276.         }
  278.         if(col[8*6]){
  279.             a0 += + W6*col[8*6];
  280.             a1 += - W2*col[8*6];
  281.             a2 += + W2*col[8*6];
  282.             a3 += - W6*col[8*6];
  283.         }
  285.         if (col[8*7]) {
  286.             MAC16(b0, + W7, col[8*7]);
  287.             MAC16(b1, - W5, col[8*7]);
  288.             MAC16(b2, + W3, col[8*7]);
  289.             MAC16(b3, - W1, col[8*7]);
  290.         }
  292.         dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];
  293.         dest += line_size;
  294.         dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];
  295.         dest += line_size;
  296.         dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];
  297.         dest += line_size;
  298.         dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];
  299.         dest += line_size;
  300.         dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];
  301.         dest += line_size;
  302.         dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];
  303.         dest += line_size;
  304.         dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];
  305.         dest += line_size;
  306.         dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];
  307. }
  309. static inline void idctSparseCol (DCTELEM * col)
  310. {
  311.         int a0, a1, a2, a3, b0, b1, b2, b3;
  313.         /* XXX: I did that only to give same values as previous code */
  314.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
  315.         a1 = a0;
  316.         a2 = a0;
  317.         a3 = a0;
  319.         a0 +=  + W2*col[8*2];
  320.         a1 +=  + W6*col[8*2];
  321.         a2 +=  - W6*col[8*2];
  322.         a3 +=  - W2*col[8*2];
  324.         b0 = MUL16(W1, col[8*1]);
  325.         b1 = MUL16(W3, col[8*1]);
  326.         b2 = MUL16(W5, col[8*1]);
  327.         b3 = MUL16(W7, col[8*1]);
  329.         MAC16(b0, + W3, col[8*3]);
  330.         MAC16(b1, - W7, col[8*3]);
  331.         MAC16(b2, - W1, col[8*3]);
  332.         MAC16(b3, - W5, col[8*3]);
  334.         if(col[8*4]){
  335.             a0 += + W4*col[8*4];
  336.             a1 += - W4*col[8*4];
  337.             a2 += - W4*col[8*4];
  338.             a3 += + W4*col[8*4];
  339.         }
  341.         if (col[8*5]) {
  342.             MAC16(b0, + W5, col[8*5]);
  343.             MAC16(b1, - W1, col[8*5]);
  344.             MAC16(b2, + W7, col[8*5]);
  345.             MAC16(b3, + W3, col[8*5]);
  346.         }
  348.         if(col[8*6]){
  349.             a0 += + W6*col[8*6];
  350.             a1 += - W2*col[8*6];
  351.             a2 += + W2*col[8*6];
  352.             a3 += - W6*col[8*6];
  353.         }
  355.         if (col[8*7]) {
  356.             MAC16(b0, + W7, col[8*7]);
  357.             MAC16(b1, - W5, col[8*7]);
  358.             MAC16(b2, + W3, col[8*7]);
  359.             MAC16(b3, - W1, col[8*7]);
  360.         }
  362.         col[0 ] = ((a0 + b0) >> COL_SHIFT);
  363.         col[8 ] = ((a1 + b1) >> COL_SHIFT);
  364.         col[16] = ((a2 + b2) >> COL_SHIFT);
  365.         col[24] = ((a3 + b3) >> COL_SHIFT);
  366.         col[32] = ((a3 - b3) >> COL_SHIFT);
  367.         col[40] = ((a2 - b2) >> COL_SHIFT);
  368.         col[48] = ((a1 - b1) >> COL_SHIFT);
  369.         col[56] = ((a0 - b0) >> COL_SHIFT);
  370. }
  372. void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
  373. {
  374.     int i;
  375.     for(i=0; i<8; i++)
  376.         idctRowCondDC(block + i*8);
  378.     for(i=0; i<8; i++)
  379.         idctSparseColPut(dest + i, line_size, block + i);
  380. }
  382. void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
  383. {
  384.     int i;
  385.     for(i=0; i<8; i++)
  386.         idctRowCondDC(block + i*8);
  388.     for(i=0; i<8; i++)
  389.         idctSparseColAdd(dest + i, line_size, block + i);
  390. }
  392. void ff_simple_idct(DCTELEM *block)
  393. {
  394.     int i;
  395.     for(i=0; i<8; i++)
  396.         idctRowCondDC(block + i*8);
  398.     for(i=0; i<8; i++)
  399.         idctSparseCol(block + i);
  400. }
  402. /* 2x4x8 idct */
  404. #define CN_SHIFT 12
  405. #define C_FIX(x) ((int)((x) * (1 << CN_SHIFT) + 0.5))
  406. #define C1 C_FIX(0.6532814824)
  407. #define C2 C_FIX(0.2705980501)
  409. /* row idct is multiple by 16 * sqrt(2.0), col idct4 is normalized,
  410.    and the butterfly must be multiplied by 0.5 * sqrt(2.0) */
  411. #define C_SHIFT (4+1+12)
  413. static inline void idct4col_put(uint8_t *dest, int line_size, const DCTELEM *col)
  414. {
  415.     int c0, c1, c2, c3, a0, a1, a2, a3;
  416.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  418.     a0 = col[8*0];
  419.     a1 = col[8*2];
  420.     a2 = col[8*4];
  421.     a3 = col[8*6];
  422.     c0 = ((a0 + a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
  423.     c2 = ((a0 - a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
  424.     c1 = a1 * C1 + a3 * C2;
  425.     c3 = a1 * C2 - a3 * C1;
  426.     dest[0] = cm[(c0 + c1) >> C_SHIFT];
  427.     dest += line_size;
  428.     dest[0] = cm[(c2 + c3) >> C_SHIFT];
  429.     dest += line_size;
  430.     dest[0] = cm[(c2 - c3) >> C_SHIFT];
  431.     dest += line_size;
  432.     dest[0] = cm[(c0 - c1) >> C_SHIFT];
  433. }
  435. #define BF(k) 
  436. {
  437.     int a0, a1;
  438.     a0 = ptr[k];
  439.     a1 = ptr[8 + k];
  440.     ptr[k] = a0 + a1;
  441.     ptr[8 + k] = a0 - a1;
  442. }
  444. /* only used by DV codec. The input must be interlaced. 128 is added
  445.    to the pixels before clamping to avoid systematic error
  446.    (1024*sqrt(2)) offset would be needed otherwise. */
  447. /* XXX: I think a 1.0/sqrt(2) normalization should be needed to
  448.    compensate the extra butterfly stage - I don't have the full DV
  449.    specification */
  450. void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
  451. {
  452.     int i;
  453.     DCTELEM *ptr;
  455.     /* butterfly */
  456.     ptr = block;
  457.     for(i=0;i<4;i++) {
  458.         BF(0);
  459.         BF(1);
  460.         BF(2);
  461.         BF(3);
  462.         BF(4);
  463.         BF(5);
  464.         BF(6);
  465.         BF(7);
  466.         ptr += 2 * 8;
  467.     }
  469.     /* IDCT8 on each line */
  470.     for(i=0; i<8; i++) {
  471.         idctRowCondDC(block + i*8);
  472.     }
  474.     /* IDCT4 and store */
  475.     for(i=0;i<8;i++) {
  476.         idct4col_put(dest + i, 2 * line_size, block + i);
  477.         idct4col_put(dest + line_size + i, 2 * line_size, block + 8 + i);
  478.     }
  479. }
  481. /* 8x4 & 4x8 WMV2 IDCT */
  482. #undef CN_SHIFT
  483. #undef C_SHIFT
  484. #undef C_FIX
  485. #undef C1
  486. #undef C2
  487. #define CN_SHIFT 12
  488. #define C_FIX(x) ((int)((x) * 1.414213562 * (1 << CN_SHIFT) + 0.5))
  489. #define C1 C_FIX(0.6532814824)
  490. #define C2 C_FIX(0.2705980501)
  491. #define C3 C_FIX(0.5)
  492. #define C_SHIFT (4+1+12)
  493. static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)
  494. {
  495.     int c0, c1, c2, c3, a0, a1, a2, a3;
  496.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  498.     a0 = col[8*0];
  499.     a1 = col[8*1];
  500.     a2 = col[8*2];
  501.     a3 = col[8*3];
  502.     c0 = (a0 + a2)*C3 + (1 << (C_SHIFT - 1));
  503.     c2 = (a0 - a2)*C3 + (1 << (C_SHIFT - 1));
  504.     c1 = a1 * C1 + a3 * C2;
  505.     c3 = a1 * C2 - a3 * C1;
  506.     dest[0] = cm[dest[0] + ((c0 + c1) >> C_SHIFT)];
  507.     dest += line_size;
  508.     dest[0] = cm[dest[0] + ((c2 + c3) >> C_SHIFT)];
  509.     dest += line_size;
  510.     dest[0] = cm[dest[0] + ((c2 - c3) >> C_SHIFT)];
  511.     dest += line_size;
  512.     dest[0] = cm[dest[0] + ((c0 - c1) >> C_SHIFT)];
  513. }
  515. #define RN_SHIFT 15
  516. #define R_FIX(x) ((int)((x) * 1.414213562 * (1 << RN_SHIFT) + 0.5))
  517. #define R1 R_FIX(0.6532814824)
  518. #define R2 R_FIX(0.2705980501)
  519. #define R3 R_FIX(0.5)
  520. #define R_SHIFT 11
  521. static inline void idct4row(DCTELEM *row)
  522. {
  523.     int c0, c1, c2, c3, a0, a1, a2, a3;
  524.     //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  526.     a0 = row[0];
  527.     a1 = row[1];
  528.     a2 = row[2];
  529.     a3 = row[3];
  530.     c0 = (a0 + a2)*R3 + (1 << (R_SHIFT - 1));
  531.     c2 = (a0 - a2)*R3 + (1 << (R_SHIFT - 1));
  532.     c1 = a1 * R1 + a3 * R2;
  533.     c3 = a1 * R2 - a3 * R1;
  534.     row[0]= (c0 + c1) >> R_SHIFT;
  535.     row[1]= (c2 + c3) >> R_SHIFT;
  536.     row[2]= (c2 - c3) >> R_SHIFT;
  537.     row[3]= (c0 - c1) >> R_SHIFT;
  538. }
  540. void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)
  541. {
  542.     int i;
  544.     /* IDCT8 on each line */
  545.     for(i=0; i<4; i++) {
  546.         idctRowCondDC(block + i*8);
  547.     }
  549.     /* IDCT4 and store */
  550.     for(i=0;i<8;i++) {
  551.         idct4col_add(dest + i, line_size, block + i);
  552.     }
  553. }
  555. void ff_simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)
  556. {
  557.     int i;
  559.     /* IDCT4 on each line */
  560.     for(i=0; i<8; i++) {
  561.         idct4row(block + i*8);
  562.     }
  564.     /* IDCT8 and store */
  565.     for(i=0; i<4; i++){
  566.         idctSparseColAdd(dest + i, line_size, block + i);
  567.     }
  568. }
  570. void ff_simple_idct44_add(uint8_t *dest, int line_size, DCTELEM *block)
  571. {
  572.     int i;
  574.     /* IDCT4 on each line */
  575.     for(i=0; i<4; i++) {
  576.         idct4row(block + i*8);
  577.     }
  579.     /* IDCT4 and store */
  580.     for(i=0; i<4; i++){
  581.         idct4col_add(dest + i, line_size, block + i);
  582.     }
  583. }