falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
29538 Commits
32 Branches
580MB
Tree: 3e9409b1d0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3e9409b1d0'
${ noResults }
FFmpeg/libavcodec/simple_idct.c

544 lines
15KB
Raw Blame History 

  1. /*

  2.  * Simple IDCT

  3.  *

  4.  * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav 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.  * Libav 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 Libav; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. /**

  24.  * @file

  25.  * simpleidct in C.

  26.  */

  27. 

  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. 

  33. #include "libavutil/intreadwrite.h"

  34. #include "avcodec.h"

  35. #include "dsputil.h"

  36. #include "mathops.h"

  37. #include "simple_idct.h"

  38. 

  39. #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  40. #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  41. #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  42. #define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  43. #define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  44. #define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  45. #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  46. #define ROW_SHIFT 11

  47. #define COL_SHIFT 20 // 6

  48. 

  49. static inline void idctRowCondDC (DCTELEM * row)

  50. {

  51.         int a0, a1, a2, a3, b0, b1, b2, b3;

  52. 

  53. #if HAVE_FAST_64BIT

  54. #define ROW0_MASK (0xffffLL << 48 * HAVE_BIGENDIAN)

  55.         if (((((uint64_t *)row)[0] & ~ROW0_MASK) | ((uint64_t *)row)[1]) == 0) {

  56.             uint64_t temp = (row[0] << 3) & 0xffff;

  57.             temp += temp << 16;

  58.             temp += temp << 32;

  59.             ((uint64_t *)row)[0] = temp;

  60.             ((uint64_t *)row)[1] = temp;

  61.             return;

  62.         }

  63. #else

  64.         if (!(((uint32_t*)row)[1] |

  65.               ((uint32_t*)row)[2] |

  66.               ((uint32_t*)row)[3] |

  67.               row[1])) {

  68.             uint32_t temp = (row[0] << 3) & 0xffff;

  69.             temp += temp << 16;

  70.             ((uint32_t*)row)[0]=((uint32_t*)row)[1] =

  71.                 ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;

  72.             return;

  73.         }

  74. #endif

  75. 

  76.         a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));

  77.         a1 = a0;

  78.         a2 = a0;

  79.         a3 = a0;

  80. 

  81.         /* no need to optimize : gcc does it */

  82.         a0 += W2 * row[2];

  83.         a1 += W6 * row[2];

  84.         a2 -= W6 * row[2];

  85.         a3 -= W2 * row[2];

  86. 

  87.         b0 = MUL16(W1, row[1]);

  88.         MAC16(b0, W3, row[3]);

  89.         b1 = MUL16(W3, row[1]);

  90.         MAC16(b1, -W7, row[3]);

  91.         b2 = MUL16(W5, row[1]);

  92.         MAC16(b2, -W1, row[3]);

  93.         b3 = MUL16(W7, row[1]);

  94.         MAC16(b3, -W5, row[3]);

  95. 

  96.         if (AV_RN64A(row + 4)) {

  97.             a0 += W4*row[4] + W6*row[6];

  98.             a1 += - W4*row[4] - W2*row[6];

  99.             a2 += - W4*row[4] + W2*row[6];

  100.             a3 += W4*row[4] - W6*row[6];

  101. 

  102.             MAC16(b0, W5, row[5]);

  103.             MAC16(b0, W7, row[7]);

  104. 

  105.             MAC16(b1, -W1, row[5]);

  106.             MAC16(b1, -W5, row[7]);

  107. 

  108.             MAC16(b2, W7, row[5]);

  109.             MAC16(b2, W3, row[7]);

  110. 

  111.             MAC16(b3, W3, row[5]);

  112.             MAC16(b3, -W1, row[7]);

  113.         }

  114. 

  115.         row[0] = (a0 + b0) >> ROW_SHIFT;

  116.         row[7] = (a0 - b0) >> ROW_SHIFT;

  117.         row[1] = (a1 + b1) >> ROW_SHIFT;

  118.         row[6] = (a1 - b1) >> ROW_SHIFT;

  119.         row[2] = (a2 + b2) >> ROW_SHIFT;

  120.         row[5] = (a2 - b2) >> ROW_SHIFT;

  121.         row[3] = (a3 + b3) >> ROW_SHIFT;

  122.         row[4] = (a3 - b3) >> ROW_SHIFT;

  123. }

  124. 

  125. static inline void idctSparseColPut (uint8_t *dest, int line_size,

  126.                                      DCTELEM * col)

  127. {

  128.         int a0, a1, a2, a3, b0, b1, b2, b3;

  129.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  130. 

  131.         /* XXX: I did that only to give same values as previous code */

  132.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  133.         a1 = a0;

  134.         a2 = a0;

  135.         a3 = a0;

  136. 

  137.         a0 +=  + W2*col[8*2];

  138.         a1 +=  + W6*col[8*2];

  139.         a2 +=  - W6*col[8*2];

  140.         a3 +=  - W2*col[8*2];

  141. 

  142.         b0 = MUL16(W1, col[8*1]);

  143.         b1 = MUL16(W3, col[8*1]);

  144.         b2 = MUL16(W5, col[8*1]);

  145.         b3 = MUL16(W7, col[8*1]);

  146. 

  147.         MAC16(b0, + W3, col[8*3]);

  148.         MAC16(b1, - W7, col[8*3]);

  149.         MAC16(b2, - W1, col[8*3]);

  150.         MAC16(b3, - W5, col[8*3]);

  151. 

  152.         if(col[8*4]){

  153.             a0 += + W4*col[8*4];

  154.             a1 += - W4*col[8*4];

  155.             a2 += - W4*col[8*4];

  156.             a3 += + W4*col[8*4];

  157.         }

  158. 

  159.         if (col[8*5]) {

  160.             MAC16(b0, + W5, col[8*5]);

  161.             MAC16(b1, - W1, col[8*5]);

  162.             MAC16(b2, + W7, col[8*5]);

  163.             MAC16(b3, + W3, col[8*5]);

  164.         }

  165. 

  166.         if(col[8*6]){

  167.             a0 += + W6*col[8*6];

  168.             a1 += - W2*col[8*6];

  169.             a2 += + W2*col[8*6];

  170.             a3 += - W6*col[8*6];

  171.         }

  172. 

  173.         if (col[8*7]) {

  174.             MAC16(b0, + W7, col[8*7]);

  175.             MAC16(b1, - W5, col[8*7]);

  176.             MAC16(b2, + W3, col[8*7]);

  177.             MAC16(b3, - W1, col[8*7]);

  178.         }

  179. 

  180.         dest[0] = cm[(a0 + b0) >> COL_SHIFT];

  181.         dest += line_size;

  182.         dest[0] = cm[(a1 + b1) >> COL_SHIFT];

  183.         dest += line_size;

  184.         dest[0] = cm[(a2 + b2) >> COL_SHIFT];

  185.         dest += line_size;

  186.         dest[0] = cm[(a3 + b3) >> COL_SHIFT];

  187.         dest += line_size;

  188.         dest[0] = cm[(a3 - b3) >> COL_SHIFT];

  189.         dest += line_size;

  190.         dest[0] = cm[(a2 - b2) >> COL_SHIFT];

  191.         dest += line_size;

  192.         dest[0] = cm[(a1 - b1) >> COL_SHIFT];

  193.         dest += line_size;

  194.         dest[0] = cm[(a0 - b0) >> COL_SHIFT];

  195. }

  196. 

  197. static inline void idctSparseColAdd (uint8_t *dest, int line_size,

  198.                                      DCTELEM * col)

  199. {

  200.         int a0, a1, a2, a3, b0, b1, b2, b3;

  201.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  202. 

  203.         /* XXX: I did that only to give same values as previous code */

  204.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  205.         a1 = a0;

  206.         a2 = a0;

  207.         a3 = a0;

  208. 

  209.         a0 +=  + W2*col[8*2];

  210.         a1 +=  + W6*col[8*2];

  211.         a2 +=  - W6*col[8*2];

  212.         a3 +=  - W2*col[8*2];

  213. 

  214.         b0 = MUL16(W1, col[8*1]);

  215.         b1 = MUL16(W3, col[8*1]);

  216.         b2 = MUL16(W5, col[8*1]);

  217.         b3 = MUL16(W7, col[8*1]);

  218. 

  219.         MAC16(b0, + W3, col[8*3]);

  220.         MAC16(b1, - W7, col[8*3]);

  221.         MAC16(b2, - W1, col[8*3]);

  222.         MAC16(b3, - W5, col[8*3]);

  223. 

  224.         if(col[8*4]){

  225.             a0 += + W4*col[8*4];

  226.             a1 += - W4*col[8*4];

  227.             a2 += - W4*col[8*4];

  228.             a3 += + W4*col[8*4];

  229.         }

  230. 

  231.         if (col[8*5]) {

  232.             MAC16(b0, + W5, col[8*5]);

  233.             MAC16(b1, - W1, col[8*5]);

  234.             MAC16(b2, + W7, col[8*5]);

  235.             MAC16(b3, + W3, col[8*5]);

  236.         }

  237. 

  238.         if(col[8*6]){

  239.             a0 += + W6*col[8*6];

  240.             a1 += - W2*col[8*6];

  241.             a2 += + W2*col[8*6];

  242.             a3 += - W6*col[8*6];

  243.         }

  244. 

  245.         if (col[8*7]) {

  246.             MAC16(b0, + W7, col[8*7]);

  247.             MAC16(b1, - W5, col[8*7]);

  248.             MAC16(b2, + W3, col[8*7]);

  249.             MAC16(b3, - W1, col[8*7]);

  250.         }

  251. 

  252.         dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];

  253.         dest += line_size;

  254.         dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];

  255.         dest += line_size;

  256.         dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];

  257.         dest += line_size;

  258.         dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];

  259.         dest += line_size;

  260.         dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];

  261.         dest += line_size;

  262.         dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];

  263.         dest += line_size;

  264.         dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];

  265.         dest += line_size;

  266.         dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];

  267. }

  268. 

  269. static inline void idctSparseCol (DCTELEM * col)

  270. {

  271.         int a0, a1, a2, a3, b0, b1, b2, b3;

  272. 

  273.         /* XXX: I did that only to give same values as previous code */

  274.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  275.         a1 = a0;

  276.         a2 = a0;

  277.         a3 = a0;

  278. 

  279.         a0 +=  + W2*col[8*2];

  280.         a1 +=  + W6*col[8*2];

  281.         a2 +=  - W6*col[8*2];

  282.         a3 +=  - W2*col[8*2];

  283. 

  284.         b0 = MUL16(W1, col[8*1]);

  285.         b1 = MUL16(W3, col[8*1]);

  286.         b2 = MUL16(W5, col[8*1]);

  287.         b3 = MUL16(W7, col[8*1]);

  288. 

  289.         MAC16(b0, + W3, col[8*3]);

  290.         MAC16(b1, - W7, col[8*3]);

  291.         MAC16(b2, - W1, col[8*3]);

  292.         MAC16(b3, - W5, col[8*3]);

  293. 

  294.         if(col[8*4]){

  295.             a0 += + W4*col[8*4];

  296.             a1 += - W4*col[8*4];

  297.             a2 += - W4*col[8*4];

  298.             a3 += + W4*col[8*4];

  299.         }

  300. 

  301.         if (col[8*5]) {

  302.             MAC16(b0, + W5, col[8*5]);

  303.             MAC16(b1, - W1, col[8*5]);

  304.             MAC16(b2, + W7, col[8*5]);

  305.             MAC16(b3, + W3, col[8*5]);

  306.         }

  307. 

  308.         if(col[8*6]){

  309.             a0 += + W6*col[8*6];

  310.             a1 += - W2*col[8*6];

  311.             a2 += + W2*col[8*6];

  312.             a3 += - W6*col[8*6];

  313.         }

  314. 

  315.         if (col[8*7]) {

  316.             MAC16(b0, + W7, col[8*7]);

  317.             MAC16(b1, - W5, col[8*7]);

  318.             MAC16(b2, + W3, col[8*7]);

  319.             MAC16(b3, - W1, col[8*7]);

  320.         }

  321. 

  322.         col[0 ] = ((a0 + b0) >> COL_SHIFT);

  323.         col[8 ] = ((a1 + b1) >> COL_SHIFT);

  324.         col[16] = ((a2 + b2) >> COL_SHIFT);

  325.         col[24] = ((a3 + b3) >> COL_SHIFT);

  326.         col[32] = ((a3 - b3) >> COL_SHIFT);

  327.         col[40] = ((a2 - b2) >> COL_SHIFT);

  328.         col[48] = ((a1 - b1) >> COL_SHIFT);

  329.         col[56] = ((a0 - b0) >> COL_SHIFT);

  330. }

  331. 

  332. void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)

  333. {

  334.     int i;

  335.     for(i=0; i<8; i++)

  336.         idctRowCondDC(block + i*8);

  337. 

  338.     for(i=0; i<8; i++)

  339.         idctSparseColPut(dest + i, line_size, block + i);

  340. }

  341. 

  342. void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)

  343. {

  344.     int i;

  345.     for(i=0; i<8; i++)

  346.         idctRowCondDC(block + i*8);

  347. 

  348.     for(i=0; i<8; i++)

  349.         idctSparseColAdd(dest + i, line_size, block + i);

  350. }

  351. 

  352. void ff_simple_idct(DCTELEM *block)

  353. {

  354.     int i;

  355.     for(i=0; i<8; i++)

  356.         idctRowCondDC(block + i*8);

  357. 

  358.     for(i=0; i<8; i++)

  359.         idctSparseCol(block + i);

  360. }

  361. 

  362. /* 2x4x8 idct */

  363. 

  364. #define CN_SHIFT 12

  365. #define C_FIX(x) ((int)((x) * (1 << CN_SHIFT) + 0.5))

  366. #define C1 C_FIX(0.6532814824)

  367. #define C2 C_FIX(0.2705980501)

  368. 

  369. /* row idct is multiple by 16 * sqrt(2.0), col idct4 is normalized,

  370.    and the butterfly must be multiplied by 0.5 * sqrt(2.0) */

  371. #define C_SHIFT (4+1+12)

  372. 

  373. static inline void idct4col_put(uint8_t *dest, int line_size, const DCTELEM *col)

  374. {

  375.     int c0, c1, c2, c3, a0, a1, a2, a3;

  376.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  377. 

  378.     a0 = col[8*0];

  379.     a1 = col[8*2];

  380.     a2 = col[8*4];

  381.     a3 = col[8*6];

  382.     c0 = ((a0 + a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));

  383.     c2 = ((a0 - a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));

  384.     c1 = a1 * C1 + a3 * C2;

  385.     c3 = a1 * C2 - a3 * C1;

  386.     dest[0] = cm[(c0 + c1) >> C_SHIFT];

  387.     dest += line_size;

  388.     dest[0] = cm[(c2 + c3) >> C_SHIFT];

  389.     dest += line_size;

  390.     dest[0] = cm[(c2 - c3) >> C_SHIFT];

  391.     dest += line_size;

  392.     dest[0] = cm[(c0 - c1) >> C_SHIFT];

  393. }

  394. 

  395. #define BF(k) \

  396. {\

  397.     int a0, a1;\

  398.     a0 = ptr[k];\

  399.     a1 = ptr[8 + k];\

  400.     ptr[k] = a0 + a1;\

  401.     ptr[8 + k] = a0 - a1;\

  402. }

  403. 

  404. /* only used by DV codec. The input must be interlaced. 128 is added

  405.    to the pixels before clamping to avoid systematic error

  406.    (1024*sqrt(2)) offset would be needed otherwise. */

  407. /* XXX: I think a 1.0/sqrt(2) normalization should be needed to

  408.    compensate the extra butterfly stage - I don't have the full DV

  409.    specification */

  410. void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)

  411. {

  412.     int i;

  413.     DCTELEM *ptr;

  414. 

  415.     /* butterfly */

  416.     ptr = block;

  417.     for(i=0;i<4;i++) {

  418.         BF(0);

  419.         BF(1);

  420.         BF(2);

  421.         BF(3);

  422.         BF(4);

  423.         BF(5);

  424.         BF(6);

  425.         BF(7);

  426.         ptr += 2 * 8;

  427.     }

  428. 

  429.     /* IDCT8 on each line */

  430.     for(i=0; i<8; i++) {

  431.         idctRowCondDC(block + i*8);

  432.     }

  433. 

  434.     /* IDCT4 and store */

  435.     for(i=0;i<8;i++) {

  436.         idct4col_put(dest + i, 2 * line_size, block + i);

  437.         idct4col_put(dest + line_size + i, 2 * line_size, block + 8 + i);

  438.     }

  439. }

  440. 

  441. /* 8x4 & 4x8 WMV2 IDCT */

  442. #undef CN_SHIFT

  443. #undef C_SHIFT

  444. #undef C_FIX

  445. #undef C1

  446. #undef C2

  447. #define CN_SHIFT 12

  448. #define C_FIX(x) ((int)((x) * 1.414213562 * (1 << CN_SHIFT) + 0.5))

  449. #define C1 C_FIX(0.6532814824)

  450. #define C2 C_FIX(0.2705980501)

  451. #define C3 C_FIX(0.5)

  452. #define C_SHIFT (4+1+12)

  453. static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)

  454. {

  455.     int c0, c1, c2, c3, a0, a1, a2, a3;

  456.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  457. 

  458.     a0 = col[8*0];

  459.     a1 = col[8*1];

  460.     a2 = col[8*2];

  461.     a3 = col[8*3];

  462.     c0 = (a0 + a2)*C3 + (1 << (C_SHIFT - 1));

  463.     c2 = (a0 - a2)*C3 + (1 << (C_SHIFT - 1));

  464.     c1 = a1 * C1 + a3 * C2;

  465.     c3 = a1 * C2 - a3 * C1;

  466.     dest[0] = cm[dest[0] + ((c0 + c1) >> C_SHIFT)];

  467.     dest += line_size;

  468.     dest[0] = cm[dest[0] + ((c2 + c3) >> C_SHIFT)];

  469.     dest += line_size;

  470.     dest[0] = cm[dest[0] + ((c2 - c3) >> C_SHIFT)];

  471.     dest += line_size;

  472.     dest[0] = cm[dest[0] + ((c0 - c1) >> C_SHIFT)];

  473. }

  474. 

  475. #define RN_SHIFT 15

  476. #define R_FIX(x) ((int)((x) * 1.414213562 * (1 << RN_SHIFT) + 0.5))

  477. #define R1 R_FIX(0.6532814824)

  478. #define R2 R_FIX(0.2705980501)

  479. #define R3 R_FIX(0.5)

  480. #define R_SHIFT 11

  481. static inline void idct4row(DCTELEM *row)

  482. {

  483.     int c0, c1, c2, c3, a0, a1, a2, a3;

  484.     //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  485. 

  486.     a0 = row[0];

  487.     a1 = row[1];

  488.     a2 = row[2];

  489.     a3 = row[3];

  490.     c0 = (a0 + a2)*R3 + (1 << (R_SHIFT - 1));

  491.     c2 = (a0 - a2)*R3 + (1 << (R_SHIFT - 1));

  492.     c1 = a1 * R1 + a3 * R2;

  493.     c3 = a1 * R2 - a3 * R1;

  494.     row[0]= (c0 + c1) >> R_SHIFT;

  495.     row[1]= (c2 + c3) >> R_SHIFT;

  496.     row[2]= (c2 - c3) >> R_SHIFT;

  497.     row[3]= (c0 - c1) >> R_SHIFT;

  498. }

  499. 

  500. void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)

  501. {

  502.     int i;

  503. 

  504.     /* IDCT8 on each line */

  505.     for(i=0; i<4; i++) {

  506.         idctRowCondDC(block + i*8);

  507.     }

  508. 

  509.     /* IDCT4 and store */

  510.     for(i=0;i<8;i++) {

  511.         idct4col_add(dest + i, line_size, block + i);

  512.     }

  513. }

  514. 

  515. void ff_simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)

  516. {

  517.     int i;

  518. 

  519.     /* IDCT4 on each line */

  520.     for(i=0; i<8; i++) {

  521.         idct4row(block + i*8);

  522.     }

  523. 

  524.     /* IDCT8 and store */

  525.     for(i=0; i<4; i++){

  526.         idctSparseColAdd(dest + i, line_size, block + i);

  527.     }

  528. }

  529. 

  530. void ff_simple_idct44_add(uint8_t *dest, int line_size, DCTELEM *block)

  531. {

  532.     int i;

  533. 

  534.     /* IDCT4 on each line */

  535.     for(i=0; i<4; i++) {

  536.         idct4row(block + i*8);

  537.     }

  538. 

  539.     /* IDCT4 and store */

  540.     for(i=0; i<4; i++){

  541.         idct4col_add(dest + i, line_size, block + i);

  542.     }

  543. }