summaryrefslogtreecommitdiff
path: root/lib/fdct.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/fdct.c')
-rw-r--r--lib/fdct.c422
1 files changed, 422 insertions, 0 deletions
diff --git a/lib/fdct.c b/lib/fdct.c
new file mode 100644
index 0000000..dc3a66f
--- /dev/null
+++ b/lib/fdct.c
@@ -0,0 +1,422 @@
+/********************************************************************
+ * *
+ * 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-11-25 11:16:38 +0000