Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/WolfireGames/overgrowth.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/Libraries/libtheora-1.1.1/lib/fdct.c
diff options
context:
space:
mode:
Diffstat (limited to 'Libraries/libtheora-1.1.1/lib/fdct.c')
-rw-r--r--Libraries/libtheora-1.1.1/lib/fdct.c422
1 files changed, 0 insertions, 422 deletions
diff --git a/Libraries/libtheora-1.1.1/lib/fdct.c b/Libraries/libtheora-1.1.1/lib/fdct.c
deleted file mode 100644
index dc3a66f2..00000000
--- a/Libraries/libtheora-1.1.1/lib/fdct.c
+++ /dev/null
@@ -1,422 +0,0 @@
-/********************************************************************
- * *
- * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE. *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
- * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
- * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
- * *
- * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009 *
- * by the Xiph.Org Foundation http://www.xiph.org/ *
- * *
- ********************************************************************
-
- function:
- last mod: $Id: fdct.c 16503 2009-08-22 18:14:02Z giles $
-
- ********************************************************************/
-#include "encint.h"
-#include "dct.h"
-
-
-
-/*Performs a forward 8 point Type-II DCT transform.
- The output is scaled by a factor of 2 from the orthonormal version of the
- transform.
- _y: The buffer to store the result in.
- Data will be placed the first 8 entries (e.g., in a row of an 8x8 block).
- _x: The input coefficients.
- Every 8th entry is used (e.g., from a column of an 8x8 block).*/
-static void oc_fdct8(ogg_int16_t _y[8],const ogg_int16_t *_x){
- int t0;
- int t1;
- int t2;
- int t3;
- int t4;
- int t5;
- int t6;
- int t7;
- int r;
- int s;
- int u;
- int v;
- /*Stage 1:*/
- /*0-7 butterfly.*/
- t0=_x[0<<3]+(int)_x[7<<3];
- t7=_x[0<<3]-(int)_x[7<<3];
- /*1-6 butterfly.*/
- t1=_x[1<<3]+(int)_x[6<<3];
- t6=_x[1<<3]-(int)_x[6<<3];
- /*2-5 butterfly.*/
- t2=_x[2<<3]+(int)_x[5<<3];
- t5=_x[2<<3]-(int)_x[5<<3];
- /*3-4 butterfly.*/
- t3=_x[3<<3]+(int)_x[4<<3];
- t4=_x[3<<3]-(int)_x[4<<3];
- /*Stage 2:*/
- /*0-3 butterfly.*/
- r=t0+t3;
- t3=t0-t3;
- t0=r;
- /*1-2 butterfly.*/
- r=t1+t2;
- t2=t1-t2;
- t1=r;
- /*6-5 butterfly.*/
- r=t6+t5;
- t5=t6-t5;
- t6=r;
- /*Stages 3 and 4 are where all the approximation occurs.
- These are chosen to be as close to an exact inverse of the approximations
- made in the iDCT as possible, while still using mostly 16-bit arithmetic.
- We use some 16x16->32 signed MACs, but those still commonly execute in 1
- cycle on a 16-bit DSP.
- For example, s=(27146*t5+0x4000>>16)+t5+(t5!=0) is an exact inverse of
- t5=(OC_C4S4*s>>16).
- That is, applying the latter to the output of the former will recover t5
- exactly (over the valid input range of t5, -23171...23169).
- We increase the rounding bias to 0xB500 in this particular case so that
- errors inverting the subsequent butterfly are not one-sided (e.g., the
- mean error is very close to zero).
- The (t5!=0) term could be replaced simply by 1, but we want to send 0 to 0.
- The fDCT of an all-zeros block will still not be zero, because of the
- biases we added at the very beginning of the process, but it will be close
- enough that it is guaranteed to round to zero.*/
- /*Stage 3:*/
- /*4-5 butterfly.*/
- s=(27146*t5+0xB500>>16)+t5+(t5!=0)>>1;
- r=t4+s;
- t5=t4-s;
- t4=r;
- /*7-6 butterfly.*/
- s=(27146*t6+0xB500>>16)+t6+(t6!=0)>>1;
- r=t7+s;
- t6=t7-s;
- t7=r;
- /*Stage 4:*/
- /*0-1 butterfly.*/
- r=(27146*t0+0x4000>>16)+t0+(t0!=0);
- s=(27146*t1+0xB500>>16)+t1+(t1!=0);
- u=r+s>>1;
- v=r-u;
- _y[0]=u;
- _y[4]=v;
- /*3-2 rotation by 6pi/16*/
- u=(OC_C6S2*t2+OC_C2S6*t3+0x6CB7>>16)+(t3!=0);
- s=(OC_C6S2*u>>16)-t2;
- v=(s*21600+0x2800>>18)+s+(s!=0);
- _y[2]=u;
- _y[6]=v;
- /*6-5 rotation by 3pi/16*/
- u=(OC_C5S3*t6+OC_C3S5*t5+0x0E3D>>16)+(t5!=0);
- s=t6-(OC_C5S3*u>>16);
- v=(s*26568+0x3400>>17)+s+(s!=0);
- _y[5]=u;
- _y[3]=v;
- /*7-4 rotation by 7pi/16*/
- u=(OC_C7S1*t4+OC_C1S7*t7+0x7B1B>>16)+(t7!=0);
- s=(OC_C7S1*u>>16)-t4;
- v=(s*20539+0x3000>>20)+s+(s!=0);
- _y[1]=u;
- _y[7]=v;
-}
-
-void oc_enc_fdct8x8(const oc_enc_ctx *_enc,ogg_int16_t _y[64],
- const ogg_int16_t _x[64]){
- (*_enc->opt_vtable.fdct8x8)(_y,_x);
-}
-
-/*Performs a forward 8x8 Type-II DCT transform.
- The output is scaled by a factor of 4 relative to the orthonormal version
- of the transform.
- _y: The buffer to store the result in.
- This may be the same as _x.
- _x: The input coefficients. */
-void oc_enc_fdct8x8_c(ogg_int16_t _y[64],const ogg_int16_t _x[64]){
- const ogg_int16_t *in;
- ogg_int16_t *end;
- ogg_int16_t *out;
- ogg_int16_t w[64];
- int i;
- /*Add two extra bits of working precision to improve accuracy; any more and
- we could overflow.*/
- for(i=0;i<64;i++)w[i]=_x[i]<<2;
- /*These biases correct for some systematic error that remains in the full
- fDCT->iDCT round trip.*/
- w[0]+=(w[0]!=0)+1;
- w[1]++;
- w[8]--;
- /*Transform columns of w into rows of _y.*/
- for(in=w,out=_y,end=out+64;out<end;in++,out+=8)oc_fdct8(out,in);
- /*Transform columns of _y into rows of w.*/
- for(in=_y,out=w,end=out+64;out<end;in++,out+=8)oc_fdct8(out,in);
- /*Round the result back to the external working precision (which is still
- scaled by four relative to the orthogonal result).
- TODO: We should just update the external working precision.*/
- for(i=0;i<64;i++)_y[i]=w[i]+2>>2;
-}
-
-
-
-/*This does not seem to outperform simple LFE border padding before MC.
- It yields higher PSNR, but much higher bitrate usage.*/
-#if 0
-typedef struct oc_extension_info oc_extension_info;
-
-
-
-/*Information needed to pad boundary blocks.
- We multiply each row/column by an extension matrix that fills in the padding
- values as a linear combination of the active values, so that an equivalent
- number of coefficients are forced to zero.
- This costs at most 16 multiplies, the same as a 1-D fDCT itself, and as
- little as 7 multiplies.
- We compute the extension matrices for every possible shape in advance, as
- there are only 35.
- The coefficients for all matrices are stored in a single array to take
- advantage of the overlap and repetitiveness of many of the shapes.
- A similar technique is applied to the offsets into this array.
- This reduces the required table storage by about 48%.
- See tools/extgen.c for details.
- We could conceivably do the same for all 256 possible shapes.*/
-struct oc_extension_info{
- /*The mask of the active pixels in the shape.*/
- short mask;
- /*The number of active pixels in the shape.*/
- short na;
- /*The extension matrix.
- This is (8-na)xna*/
- const ogg_int16_t *const *ext;
- /*The pixel indices: na active pixels followed by 8-na padding pixels.*/
- unsigned char pi[8];
- /*The coefficient indices: na unconstrained coefficients followed by 8-na
- coefficients to be forced to zero.*/
- unsigned char ci[8];
-};
-
-
-/*The number of shapes we need.*/
-#define OC_NSHAPES (35)
-
-static const ogg_int16_t OC_EXT_COEFFS[229]={
- 0x7FFF,0xE1F8,0x6903,0xAA79,0x5587,0x7FFF,0x1E08,0x7FFF,
- 0x5587,0xAA79,0x6903,0xE1F8,0x7FFF,0x0000,0x0000,0x0000,
- 0x7FFF,0x0000,0x0000,0x7FFF,0x8000,0x7FFF,0x0000,0x0000,
- 0x7FFF,0xE1F8,0x1E08,0xB0A7,0xAA1D,0x337C,0x7FFF,0x4345,
- 0x2267,0x4345,0x7FFF,0x337C,0xAA1D,0xB0A7,0x8A8C,0x4F59,
- 0x03B4,0xE2D6,0x7FFF,0x2CF3,0x7FFF,0xE2D6,0x03B4,0x4F59,
- 0x8A8C,0x1103,0x7AEF,0x5225,0xDF60,0xC288,0xDF60,0x5225,
- 0x7AEF,0x1103,0x668A,0xD6EE,0x3A16,0x0E6C,0xFA07,0x0E6C,
- 0x3A16,0xD6EE,0x668A,0x2A79,0x2402,0x980F,0x50F5,0x4882,
- 0x50F5,0x980F,0x2402,0x2A79,0xF976,0x2768,0x5F22,0x2768,
- 0xF976,0x1F91,0x76C1,0xE9AE,0x76C1,0x1F91,0x7FFF,0xD185,
- 0x0FC8,0xD185,0x7FFF,0x4F59,0x4345,0xED62,0x4345,0x4F59,
- 0xF574,0x5D99,0x2CF3,0x5D99,0xF574,0x5587,0x3505,0x30FC,
- 0xF482,0x953C,0xEAC4,0x7FFF,0x4F04,0x7FFF,0xEAC4,0x953C,
- 0xF482,0x30FC,0x4F04,0x273D,0xD8C3,0x273D,0x1E09,0x61F7,
- 0x1E09,0x273D,0xD8C3,0x273D,0x4F04,0x30FC,0xA57E,0x153C,
- 0x6AC4,0x3C7A,0x1E08,0x3C7A,0x6AC4,0x153C,0xA57E,0x7FFF,
- 0xA57E,0x5A82,0x6AC4,0x153C,0xC386,0xE1F8,0xC386,0x153C,
- 0x6AC4,0x5A82,0xD8C3,0x273D,0x7FFF,0xE1F7,0x7FFF,0x273D,
- 0xD8C3,0x4F04,0x30FC,0xD8C3,0x273D,0xD8C3,0x30FC,0x4F04,
- 0x1FC8,0x67AD,0x1853,0xE038,0x1853,0x67AD,0x1FC8,0x4546,
- 0xE038,0x1FC8,0x3ABA,0x1FC8,0xE038,0x4546,0x3505,0x5587,
- 0xF574,0xBC11,0x78F4,0x4AFB,0xE6F3,0x4E12,0x3C11,0xF8F4,
- 0x4AFB,0x3C7A,0xF88B,0x3C11,0x78F4,0xCAFB,0x7FFF,0x08CC,
- 0x070C,0x236D,0x5587,0x236D,0x070C,0xF88B,0x3C7A,0x4AFB,
- 0xF8F4,0x3C11,0x7FFF,0x153C,0xCAFB,0x153C,0x7FFF,0x1E08,
- 0xE1F8,0x7FFF,0x08CC,0x7FFF,0xCAFB,0x78F4,0x3C11,0x4E12,
- 0xE6F3,0x4AFB,0x78F4,0xBC11,0xFE3D,0x7FFF,0xFE3D,0x2F3A,
- 0x7FFF,0x2F3A,0x89BC,0x7FFF,0x89BC
-};
-
-static const ogg_int16_t *const OC_EXT_ROWS[96]={
- OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 0,
- OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 0,OC_EXT_COEFFS+ 6,
- OC_EXT_COEFFS+ 27,OC_EXT_COEFFS+ 38,OC_EXT_COEFFS+ 43,OC_EXT_COEFFS+ 32,
- OC_EXT_COEFFS+ 49,OC_EXT_COEFFS+ 58,OC_EXT_COEFFS+ 67,OC_EXT_COEFFS+ 71,
- OC_EXT_COEFFS+ 62,OC_EXT_COEFFS+ 53,OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 15,
- OC_EXT_COEFFS+ 14,OC_EXT_COEFFS+ 13,OC_EXT_COEFFS+ 76,OC_EXT_COEFFS+ 81,
- OC_EXT_COEFFS+ 86,OC_EXT_COEFFS+ 91,OC_EXT_COEFFS+ 96,OC_EXT_COEFFS+ 98,
- OC_EXT_COEFFS+ 93,OC_EXT_COEFFS+ 88,OC_EXT_COEFFS+ 83,OC_EXT_COEFFS+ 78,
- OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 15,OC_EXT_COEFFS+ 15,OC_EXT_COEFFS+ 12,
- OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 15,OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 15,
- OC_EXT_COEFFS+ 15,OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 103,OC_EXT_COEFFS+ 108,
- OC_EXT_COEFFS+ 126,OC_EXT_COEFFS+ 16,OC_EXT_COEFFS+ 137,OC_EXT_COEFFS+ 141,
- OC_EXT_COEFFS+ 20,OC_EXT_COEFFS+ 130,OC_EXT_COEFFS+ 113,OC_EXT_COEFFS+ 116,
- OC_EXT_COEFFS+ 146,OC_EXT_COEFFS+ 153,OC_EXT_COEFFS+ 160,OC_EXT_COEFFS+ 167,
- OC_EXT_COEFFS+ 170,OC_EXT_COEFFS+ 163,OC_EXT_COEFFS+ 156,OC_EXT_COEFFS+ 149,
- OC_EXT_COEFFS+ 119,OC_EXT_COEFFS+ 122,OC_EXT_COEFFS+ 174,OC_EXT_COEFFS+ 177,
- OC_EXT_COEFFS+ 182,OC_EXT_COEFFS+ 187,OC_EXT_COEFFS+ 192,OC_EXT_COEFFS+ 197,
- OC_EXT_COEFFS+ 202,OC_EXT_COEFFS+ 207,OC_EXT_COEFFS+ 210,OC_EXT_COEFFS+ 215,
- OC_EXT_COEFFS+ 179,OC_EXT_COEFFS+ 189,OC_EXT_COEFFS+ 24,OC_EXT_COEFFS+ 204,
- OC_EXT_COEFFS+ 184,OC_EXT_COEFFS+ 194,OC_EXT_COEFFS+ 212,OC_EXT_COEFFS+ 199,
- OC_EXT_COEFFS+ 217,OC_EXT_COEFFS+ 100,OC_EXT_COEFFS+ 134,OC_EXT_COEFFS+ 135,
- OC_EXT_COEFFS+ 135,OC_EXT_COEFFS+ 12,OC_EXT_COEFFS+ 15,OC_EXT_COEFFS+ 134,
- OC_EXT_COEFFS+ 134,OC_EXT_COEFFS+ 135,OC_EXT_COEFFS+ 220,OC_EXT_COEFFS+ 223,
- OC_EXT_COEFFS+ 226,OC_EXT_COEFFS+ 227,OC_EXT_COEFFS+ 224,OC_EXT_COEFFS+ 221
-};
-
-static const oc_extension_info OC_EXTENSION_INFO[OC_NSHAPES]={
- {0x7F,7,OC_EXT_ROWS+ 0,{0,1,2,3,4,5,6,7},{0,1,2,4,5,6,7,3}},
- {0xFE,7,OC_EXT_ROWS+ 7,{1,2,3,4,5,6,7,0},{0,1,2,4,5,6,7,3}},
- {0x3F,6,OC_EXT_ROWS+ 8,{0,1,2,3,4,5,7,6},{0,1,3,4,6,7,5,2}},
- {0xFC,6,OC_EXT_ROWS+ 10,{2,3,4,5,6,7,1,0},{0,1,3,4,6,7,5,2}},
- {0x1F,5,OC_EXT_ROWS+ 12,{0,1,2,3,4,7,6,5},{0,2,3,5,7,6,4,1}},
- {0xF8,5,OC_EXT_ROWS+ 15,{3,4,5,6,7,2,1,0},{0,2,3,5,7,6,4,1}},
- {0x0F,4,OC_EXT_ROWS+ 18,{0,1,2,3,7,6,5,4},{0,2,4,6,7,5,3,1}},
- {0xF0,4,OC_EXT_ROWS+ 18,{4,5,6,7,3,2,1,0},{0,2,4,6,7,5,3,1}},
- {0x07,3,OC_EXT_ROWS+ 22,{0,1,2,7,6,5,4,3},{0,3,6,7,5,4,2,1}},
- {0xE0,3,OC_EXT_ROWS+ 27,{5,6,7,4,3,2,1,0},{0,3,6,7,5,4,2,1}},
- {0x03,2,OC_EXT_ROWS+ 32,{0,1,7,6,5,4,3,2},{0,4,7,6,5,3,2,1}},
- {0xC0,2,OC_EXT_ROWS+ 32,{6,7,5,4,3,2,1,0},{0,4,7,6,5,3,2,1}},
- {0x01,1,OC_EXT_ROWS+ 0,{0,7,6,5,4,3,2,1},{0,7,6,5,4,3,2,1}},
- {0x80,1,OC_EXT_ROWS+ 0,{7,6,5,4,3,2,1,0},{0,7,6,5,4,3,2,1}},
- {0x7E,6,OC_EXT_ROWS+ 42,{1,2,3,4,5,6,7,0},{0,1,2,5,6,7,4,3}},
- {0x7C,5,OC_EXT_ROWS+ 44,{2,3,4,5,6,7,1,0},{0,1,4,5,7,6,3,2}},
- {0x3E,5,OC_EXT_ROWS+ 47,{1,2,3,4,5,7,6,0},{0,1,4,5,7,6,3,2}},
- {0x78,4,OC_EXT_ROWS+ 50,{3,4,5,6,7,2,1,0},{0,4,5,7,6,3,2,1}},
- {0x3C,4,OC_EXT_ROWS+ 54,{2,3,4,5,7,6,1,0},{0,3,4,7,6,5,2,1}},
- {0x1E,4,OC_EXT_ROWS+ 58,{1,2,3,4,7,6,5,0},{0,4,5,7,6,3,2,1}},
- {0x70,3,OC_EXT_ROWS+ 62,{4,5,6,7,3,2,1,0},{0,5,7,6,4,3,2,1}},
- {0x38,3,OC_EXT_ROWS+ 67,{3,4,5,7,6,2,1,0},{0,5,6,7,4,3,2,1}},
- {0x1C,3,OC_EXT_ROWS+ 72,{2,3,4,7,6,5,1,0},{0,5,6,7,4,3,2,1}},
- {0x0E,3,OC_EXT_ROWS+ 77,{1,2,3,7,6,5,4,0},{0,5,7,6,4,3,2,1}},
- {0x60,2,OC_EXT_ROWS+ 82,{5,6,7,4,3,2,1,0},{0,2,7,6,5,4,3,1}},
- {0x30,2,OC_EXT_ROWS+ 36,{4,5,7,6,3,2,1,0},{0,4,7,6,5,3,2,1}},
- {0x18,2,OC_EXT_ROWS+ 90,{3,4,7,6,5,2,1,0},{0,1,7,6,5,4,3,2}},
- {0x0C,2,OC_EXT_ROWS+ 34,{2,3,7,6,5,4,1,0},{0,4,7,6,5,3,2,1}},
- {0x06,2,OC_EXT_ROWS+ 84,{1,2,7,6,5,4,3,0},{0,2,7,6,5,4,3,1}},
- {0x40,1,OC_EXT_ROWS+ 0,{6,7,5,4,3,2,1,0},{0,7,6,5,4,3,2,1}},
- {0x20,1,OC_EXT_ROWS+ 0,{5,7,6,4,3,2,1,0},{0,7,6,5,4,3,2,1}},
- {0x10,1,OC_EXT_ROWS+ 0,{4,7,6,5,3,2,1,0},{0,7,6,5,4,3,2,1}},
- {0x08,1,OC_EXT_ROWS+ 0,{3,7,6,5,4,2,1,0},{0,7,6,5,4,3,2,1}},
- {0x04,1,OC_EXT_ROWS+ 0,{2,7,6,5,4,3,1,0},{0,7,6,5,4,3,2,1}},
- {0x02,1,OC_EXT_ROWS+ 0,{1,7,6,5,4,3,2,0},{0,7,6,5,4,3,2,1}}
-};
-
-
-
-/*Pads a single column of a partial block and then performs a forward Type-II
- DCT on the result.
- The input is scaled by a factor of 4 and biased appropriately for the current
- fDCT implementation.
- The output is scaled by an additional factor of 2 from the orthonormal
- version of the transform.
- _y: The buffer to store the result in.
- Data will be placed the first 8 entries (e.g., in a row of an 8x8 block).
- _x: The input coefficients.
- Every 8th entry is used (e.g., from a column of an 8x8 block).
- _e: The extension information for the shape.*/
-static void oc_fdct8_ext(ogg_int16_t _y[8],ogg_int16_t *_x,
- const oc_extension_info *_e){
- const unsigned char *pi;
- int na;
- na=_e->na;
- pi=_e->pi;
- if(na==1){
- int ci;
- /*While the branch below is still correct for shapes with na==1, we can
- perform the entire transform with just 1 multiply in this case instead
- of 23.*/
- _y[0]=(ogg_int16_t)(OC_DIV2_16(OC_C4S4*(_x[pi[0]])));
- for(ci=1;ci<8;ci++)_y[ci]=0;
- }
- else{
- const ogg_int16_t *const *ext;
- int zpi;
- int api;
- int nz;
- /*First multiply by the extension matrix to compute the padding values.*/
- nz=8-na;
- ext=_e->ext;
- for(zpi=0;zpi<nz;zpi++){
- ogg_int32_t v;
- v=0;
- for(api=0;api<na;api++){
- v+=ext[zpi][api]*(ogg_int32_t)(_x[pi[api]<<3]<<1);
- }
- _x[pi[na+zpi]<<3]=(ogg_int16_t)(v+0x8000>>16)+1>>1;
- }
- oc_fdct8(_y,_x);
- }
-}
-
-/*Performs a forward 8x8 Type-II DCT transform on blocks which overlap the
- border of the picture region.
- This method ONLY works with rectangular regions.
- _border: A description of which pixels are inside the border.
- _y: The buffer to store the result in.
- This may be the same as _x.
- _x: The input pixel values.
- Pixel values outside the border will be ignored.*/
-void oc_fdct8x8_border(const oc_border_info *_border,
- ogg_int16_t _y[64],const ogg_int16_t _x[64]){
- ogg_int16_t *in;
- ogg_int16_t *out;
- ogg_int16_t w[64];
- ogg_int64_t mask;
- const oc_extension_info *cext;
- const oc_extension_info *rext;
- int cmask;
- int rmask;
- int ri;
- int ci;
- /*Identify the shapes of the non-zero rows and columns.*/
- rmask=cmask=0;
- mask=_border->mask;
- for(ri=0;ri<8;ri++){
- /*This aggregation is _only_ correct for rectangular masks.*/
- cmask|=((mask&0xFF)!=0)<<ri;
- rmask|=mask&0xFF;
- mask>>=8;
- }
- /*Find the associated extension info for these shapes.*/
- if(cmask==0xFF)cext=NULL;
- else for(cext=OC_EXTENSION_INFO;cext->mask!=cmask;){
- /*If we somehow can't find the shape, then just do an unpadded fDCT.
- It won't be efficient, but it should still be correct.*/
- if(++cext>=OC_EXTENSION_INFO+OC_NSHAPES){
- oc_enc_fdct8x8_c(_y,_x);
- return;
- }
- }
- if(rmask==0xFF)rext=NULL;
- else for(rext=OC_EXTENSION_INFO;rext->mask!=rmask;){
- /*If we somehow can't find the shape, then just do an unpadded fDCT.
- It won't be efficient, but it should still be correct.*/
- if(++rext>=OC_EXTENSION_INFO+OC_NSHAPES){
- oc_enc_fdct8x8_c(_y,_x);
- return;
- }
- }
- /*Add two extra bits of working precision to improve accuracy; any more and
- we could overflow.*/
- for(ci=0;ci<64;ci++)w[ci]=_x[ci]<<2;
- /*These biases correct for some systematic error that remains in the full
- fDCT->iDCT round trip.
- We can safely add them before padding, since if these pixel values are
- overwritten, we didn't care what they were anyway (and the unbiased values
- will usually yield smaller DCT coefficient magnitudes).*/
- w[0]+=(w[0]!=0)+1;
- w[1]++;
- w[8]--;
- /*Transform the columns.
- We can ignore zero columns without a problem.*/
- in=w;
- out=_y;
- if(cext==NULL)for(ci=0;ci<8;ci++)oc_fdct8(out+(ci<<3),in+ci);
- else for(ci=0;ci<8;ci++)if(rmask&(1<<ci))oc_fdct8_ext(out+(ci<<3),in+ci,cext);
- /*Transform the rows.
- We transform even rows that are supposedly zero, because rounding errors
- may make them slightly non-zero, and this will give a more precise
- reconstruction with very small quantizers.*/
- in=_y;
- out=w;
- if(rext==NULL)for(ri=0;ri<8;ri++)oc_fdct8(out+(ri<<3),in+ri);
- else for(ri=0;ri<8;ri++)oc_fdct8_ext(out+(ri<<3),in+ri,rext);
- /*Round the result back to the external working precision (which is still
- scaled by four relative to the orthogonal result).
- TODO: We should just update the external working precision.*/
- for(ci=0;ci<64;ci++)_y[ci]=w[ci]+2>>2;
-}
-#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-11 01:21:35 +0300