Cinelerra: hvirtual/quicktime/revdct.c Source File

00001 #include "sizes.h"
00002 
00003 #ifdef RIGHT_SHIFT_IS_UNSIGNED
00004 #define SHIFT_TEMPS     long shift_temp;
00005 #define RIGHT_SHIFT(x, shft) \
00006         ((shift_temp = (x)) < 0 ? \
00007          (shift_temp >> (shft)) | ((~((long) 0)) << (32-(shft))) : \
00008          (shift_temp >> (shft)))
00009 #else
00010 #define SHIFT_TEMPS
00011 #define RIGHT_SHIFT(x, shft) ((x) >> (shft))
00012 #endif
00013 
00014 #define MAXJSAMPLE 255
00015 #define RANGE_MASK  (MAXJSAMPLE * 4 + 3)
00016 #define CONST_SCALE (ONE << CONST_BITS)
00017 #define ONE     ((long)1)
00018 #define CONST_BITS 13
00019 #define PASS1_BITS  2
00020 #define DCTSIZE1 8
00021 #define DCTSIZE2 64
00022 #define MULTIPLY(var, const) ((var) * (const))
00023 #define FIX(x)  ((long)((x) * CONST_SCALE + 0.5))
00024 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n) - 1)), n)
00025 
00026 int quicktime_rev_dct(int16_t *data, unsigned char *outptr, unsigned char *rnglimit)
00027 {
00028         long tmp0, tmp1, tmp2, tmp3;
00029         long tmp10, tmp11, tmp12, tmp13;
00030         long z1, z2, z3, z4, z5;
00031         long d0, d1, d2, d3, d4, d5, d6, d7;
00032         register int16_t *dataptr;
00033         int rowctr;
00034         SHIFT_TEMPS
00035 
00036 /* Pass 1: process rows. */
00037 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
00038 /* furthermore, we scale the results by 2**PASS1_BITS. */
00039 
00040         dataptr = data;
00041 
00042         for(rowctr = DCTSIZE1 - 1; rowctr >= 0; rowctr--) 
00043         {
00044 /* Due to quantization, we will usually find that many of the input
00045  * coefficients are zero, especially the AC terms.  We can exploit this
00046  * by short-circuiting the IDCT calculation for any row in which all
00047  * the AC terms are zero.  In that case each output is equal to the
00048  * DC coefficient (with scale factor as needed).
00049  * With typical images and quantization tables, half or more of the
00050  * row DCT calculations can be simplified this way.
00051  */
00052 
00053         register int *idataptr = (int*)dataptr;
00054         d0 = dataptr[0];
00055         d1 = dataptr[1];
00056         if((d1 == 0) && (idataptr[1] | idataptr[2] | idataptr[3]) == 0) 
00057                 {
00058 /* AC terms all zero */
00059                 if(d0) 
00060                         {
00061 /* Compute a 32 bit value to assign. */
00062                                 int16_t dcval = (int16_t) (d0 << PASS1_BITS);
00063                                 register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
00064 
00065                                 idataptr[0] = v;
00066                                 idataptr[1] = v;
00067                                 idataptr[2] = v;
00068                                 idataptr[3] = v;
00069                 }
00070 
00071 /* advance pointer to next row */
00072                 dataptr += DCTSIZE1;    
00073                 continue;
00074         }
00075         d2 = dataptr[2];
00076         d3 = dataptr[3];
00077         d4 = dataptr[4];
00078         d5 = dataptr[5];
00079         d6 = dataptr[6];
00080         d7 = dataptr[7];
00081 
00082         /* Even part: reverse the even part of the forward DCT. */
00083         /* The rotator is sqrt(2)*c(-6). */
00084         if(d6)
00085                 {
00086                         if(d4) 
00087                         {
00088                         if(d2)
00089                                 {
00090                                         if(d0)
00091                                         {
00092 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
00093                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00094                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00095                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00096 
00097                                         tmp0 = (d0 + d4) << CONST_BITS;
00098                                         tmp1 = (d0 - d4) << CONST_BITS;
00099 
00100                                         tmp10 = tmp0 + tmp3;
00101                                         tmp13 = tmp0 - tmp3;
00102                                         tmp11 = tmp1 + tmp2;
00103                                         tmp12 = tmp1 - tmp2;
00104                                         } 
00105                                         else 
00106                                         {
00107 /* d*0 == 0, d2 != 0, d4 != 0, d6 != 0 */
00108                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00109                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00110                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00111 
00112                                         tmp0 = d4 << CONST_BITS;
00113 
00114                                         tmp10 = tmp0 + tmp3;
00115                                         tmp13 = tmp0 - tmp3;
00116                                         tmp11 = tmp2 - tmp0;
00117                                         tmp12 = -(tmp0 + tmp2);
00118                                         }
00119                         } 
00120                                 else 
00121                                 {
00122                                         if(d0) 
00123                                         {
00124 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
00125                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00126                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00127 
00128                                         tmp0 = (d0 + d4) << CONST_BITS;
00129                                         tmp1 = (d0 - d4) << CONST_BITS;
00130 
00131                                         tmp10 = tmp0 + tmp3;
00132                                         tmp13 = tmp0 - tmp3;
00133                                         tmp11 = tmp1 + tmp2;
00134                                         tmp12 = tmp1 - tmp2;
00135                                         } 
00136                                         else 
00137                                         {
00138 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
00139                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00140                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00141 
00142                                         tmp0 = d4 << CONST_BITS;
00143 
00144                                         tmp10 = tmp0 + tmp3;
00145                                         tmp13 = tmp0 - tmp3;
00146                                         tmp11 = tmp2 - tmp0;
00147                                         tmp12 = -(tmp0 + tmp2);
00148                                         }
00149                         }
00150                         } 
00151                         else 
00152                         {
00153                         if (d2) 
00154                                 {
00155                                         if (d0) 
00156                                         {
00157 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
00158                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00159                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00160                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00161 
00162                                         tmp0 = d0 << CONST_BITS;
00163 
00164                                         tmp10 = tmp0 + tmp3;
00165                                         tmp13 = tmp0 - tmp3;
00166                                         tmp11 = tmp0 + tmp2;
00167                                         tmp12 = tmp0 - tmp2;
00168                                         } 
00169                                         else 
00170                                         {
00171 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
00172                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00173                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00174                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00175 
00176                                         tmp10 = tmp3;
00177                                         tmp13 = -tmp3;
00178                                         tmp11 = tmp2;
00179                                         tmp12 = -tmp2;
00180                                         }
00181                         } 
00182                                 else 
00183                                 {
00184                                         if(d0) 
00185                                         {
00186 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
00187                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00188                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00189 
00190                                         tmp0 = d0 << CONST_BITS;
00191 
00192                                         tmp10 = tmp0 + tmp3;
00193                                         tmp13 = tmp0 - tmp3;
00194                                         tmp11 = tmp0 + tmp2;
00195                                         tmp12 = tmp0 - tmp2;
00196                                         } 
00197                                         else 
00198                                         {
00199 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
00200                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00201                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00202 
00203                                         tmp10 = tmp3;
00204                                         tmp13 = -tmp3;
00205                                         tmp11 = tmp2;
00206                                         tmp12 = -tmp2;
00207                                         }
00208                         }
00209                         }
00210         } 
00211                 else 
00212                 {
00213                         if(d4) 
00214                         {
00215                         if(d2) 
00216                                 {
00217                                         if(d0) 
00218                                         {
00219 /* d*0 != 0, d2 != 0, d4 != 0, d6 == 0 */
00220                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00221                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00222 
00223                                         tmp0 = (d0 + d4) << CONST_BITS;
00224                                         tmp1 = (d0 - d4) << CONST_BITS;
00225 
00226                                         tmp10 = tmp0 + tmp3;
00227                                         tmp13 = tmp0 - tmp3;
00228                                         tmp11 = tmp1 + tmp2;
00229                                         tmp12 = tmp1 - tmp2;
00230                                         } 
00231                                         else 
00232                                         {
00233 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
00234                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00235                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00236 
00237                                         tmp0 = d4 << CONST_BITS;
00238 
00239                                         tmp10 = tmp0 + tmp3;
00240                                         tmp13 = tmp0 - tmp3;
00241                                         tmp11 = tmp2 - tmp0;
00242                                         tmp12 = -(tmp0 + tmp2);
00243                                         }
00244                         } 
00245                                 else 
00246                                 {
00247                                         if(d0) 
00248                                         {
00249 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
00250                                         tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
00251                                         tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
00252                                         } 
00253                                         else 
00254                                         {
00255 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
00256                                         tmp10 = tmp13 = d4 << CONST_BITS;
00257                                         tmp11 = tmp12 = -tmp10;
00258                                         }
00259                         }
00260                         } 
00261                         else 
00262                         {
00263                         if(d2) 
00264                                 {
00265                                         if(d0) 
00266                                         {
00267 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
00268                                                 tmp2 = MULTIPLY(d2, FIX(0.541196100));
00269                                                 tmp3 = MULTIPLY(d2, FIX(1.306562965));
00270 
00271                                                 tmp0 = d0 << CONST_BITS;
00272 
00273                                                 tmp10 = tmp0 + tmp3;
00274                                                 tmp13 = tmp0 - tmp3;
00275                                                 tmp11 = tmp0 + tmp2;
00276                                                 tmp12 = tmp0 - tmp2;
00277                                         } 
00278                                         else 
00279                                         {
00280 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
00281                                                 tmp2 = MULTIPLY(d2, FIX(0.541196100));
00282                                                 tmp3 = MULTIPLY(d2, FIX(1.306562965));
00283 
00284                                                 tmp10 = tmp3;
00285                                                 tmp13 = -tmp3;
00286                                                 tmp11 = tmp2;
00287                                                 tmp12 = -tmp2;
00288                                         }
00289                         } 
00290                                 else 
00291                                 {
00292                                         if(d0) 
00293                                         {
00294 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
00295                                         tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
00296                                         } 
00297                                         else 
00298                                         {
00299 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
00300                                         tmp10 = tmp13 = tmp11 = tmp12 = 0;
00301                                         }
00302                         }
00303                         }
00304         }
00305 
00306 
00307 /* Odd part per figure 8; the matrix is unitary and hence its
00308  * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
00309  */
00310 
00311         if(d7) 
00312                 {
00313                         if(d5) 
00314                         {
00315                         if(d3) 
00316                                 {
00317                                         if(d1) 
00318                                         {
00319 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
00320                                         z1 = d7 + d1;
00321                                         z2 = d5 + d3;
00322                                         z3 = d7 + d3;
00323                                         z4 = d5 + d1;
00324                                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
00325 
00326                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00327                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00328                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00329                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00330                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00331                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
00332                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
00333                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
00334 
00335                                         z3 += z5;
00336                                         z4 += z5;
00337 
00338                                         tmp0 += z1 + z3;
00339                                         tmp1 += z2 + z4;
00340                                         tmp2 += z2 + z3;
00341                                         tmp3 += z1 + z4;
00342                                         }
00343                                         else 
00344                                         {
00345 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
00346                                         z1 = d7;
00347                                         z2 = d5 + d3;
00348                                         z3 = d7 + d3;
00349                                         z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
00350 
00351                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00352                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00353                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00354                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
00355                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
00356                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
00357                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
00358 
00359                                         z3 += z5;
00360                                         z4 += z5;
00361 
00362                                         tmp0 += z1 + z3;
00363                                         tmp1 += z2 + z4;
00364                                         tmp2 += z2 + z3;
00365                                         tmp3 = z1 + z4;
00366                                         }
00367                         } 
00368                                 else 
00369                                 {
00370                                         if(d1) 
00371                                         {
00372 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
00373                                         z1 = d7 + d1;
00374                                         z2 = d5;
00375                                         z3 = d7;
00376                                         z4 = d5 + d1;
00377                                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
00378 
00379                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00380                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00381                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00382                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00383                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
00384                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
00385                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
00386 
00387                                         z3 += z5;
00388                                         z4 += z5;
00389 
00390                                         tmp0 += z1 + z3;
00391                                         tmp1 += z2 + z4;
00392                                         tmp2 = z2 + z3;
00393                                         tmp3 += z1 + z4;
00394                                         } 
00395                                         else 
00396                                         {
00397 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
00398                                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
00399                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
00400                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
00401                                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
00402                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
00403                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
00404                                         z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
00405 
00406                                         z3 += z5;
00407                                         z4 += z5;
00408 
00409                                         tmp0 += z3;
00410                                         tmp1 += z4;
00411                                         tmp2 = z2 + z3;
00412                                         tmp3 = z1 + z4;
00413                                         }
00414                         }
00415                         } 
00416                         else 
00417                         {
00418                         if(d3) 
00419                                 {
00420                                         if(d1) 
00421                                         {
00422 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
00423                                         z1 = d7 + d1;
00424                                         z3 = d7 + d3;
00425                                         z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
00426 
00427                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00428                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00429                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00430                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00431                                         z2 = MULTIPLY(d3, -FIX(2.562915447));
00432                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
00433                                         z4 = MULTIPLY(d1, -FIX(0.390180644));
00434 
00435                                         z3 += z5;
00436                                         z4 += z5;
00437 
00438                                         tmp0 += z1 + z3;
00439                                         tmp1 = z2 + z4;
00440                                         tmp2 += z2 + z3;
00441                                         tmp3 += z1 + z4;
00442                                         } 
00443                                         else 
00444                                         {
00445 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
00446                                         z3 = d7 + d3;
00447 
00448                                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
00449                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
00450                                         tmp2 = MULTIPLY(d3, FIX(0.509795579));
00451                                         z2 = MULTIPLY(d3, -FIX(2.562915447));
00452                                         z5 = MULTIPLY(z3, FIX(1.175875602));
00453                                         z3 = MULTIPLY(z3, -FIX(0.785694958));
00454 
00455                                         tmp0 += z3;
00456                                         tmp1 = z2 + z5;
00457                                         tmp2 += z3;
00458                                         tmp3 = z1 + z5;
00459                                         }
00460                                 } 
00461                                 else 
00462                                 {
00463                                         if(d1) 
00464                                         {
00465 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
00466                                         z1 = d7 + d1;
00467                                         z5 = MULTIPLY(z1, FIX(1.175875602));
00468 
00469                                         z1 = MULTIPLY(z1, FIX(0.275899379));
00470                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
00471                                         tmp0 = MULTIPLY(d7, -FIX(1.662939224)); 
00472                                         z4 = MULTIPLY(d1, -FIX(0.390180644));
00473                                         tmp3 = MULTIPLY(d1, FIX(1.111140466));
00474 
00475                                         tmp0 += z1;
00476                                         tmp1 = z4 + z5;
00477                                         tmp2 = z3 + z5;
00478                                         tmp3 += z1;
00479                                         } 
00480                                         else 
00481                                         {
00482 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
00483                                         tmp0 = MULTIPLY(d7, -FIX(1.387039845));
00484                                         tmp1 = MULTIPLY(d7, FIX(1.175875602));
00485                                         tmp2 = MULTIPLY(d7, -FIX(0.785694958));
00486                                         tmp3 = MULTIPLY(d7, FIX(0.275899379));
00487                                         }
00488                         }
00489                         }
00490         } 
00491                 else 
00492                 {
00493                         if(d5) 
00494                         {
00495                         if(d3) 
00496                                 {
00497                                         if(d1) 
00498                                         {
00499 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
00500                                         z2 = d5 + d3;
00501                                         z4 = d5 + d1;
00502                                         z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
00503 
00504                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00505                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00506                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00507                                         z1 = MULTIPLY(d1, -FIX(0.899976223));
00508                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
00509                                         z3 = MULTIPLY(d3, -FIX(1.961570560));
00510                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
00511 
00512                                         z3 += z5;
00513                                         z4 += z5;
00514 
00515                                         tmp0 = z1 + z3;
00516                                         tmp1 += z2 + z4;
00517                                         tmp2 += z2 + z3;
00518                                         tmp3 += z1 + z4;
00519                                         } 
00520                                         else 
00521                                         {
00522 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
00523                                         z2 = d5 + d3;
00524 
00525                                         z5 = MULTIPLY(z2, FIX(1.175875602));
00526                                         tmp1 = MULTIPLY(d5, FIX(1.662939225));
00527                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
00528                                         z2 = MULTIPLY(z2, -FIX(1.387039845));
00529                                         tmp2 = MULTIPLY(d3, FIX(1.111140466));
00530                                         z3 = MULTIPLY(d3, -FIX(1.961570560));
00531 
00532                                         tmp0 = z3 + z5;
00533                                         tmp1 += z2;
00534                                         tmp2 += z2;
00535                                         tmp3 = z4 + z5;
00536                                         }
00537                         } 
00538                                 else 
00539                                 {
00540                                         if(d1) 
00541                                         {
00542 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
00543                                         z4 = d5 + d1;
00544 
00545                                         z5 = MULTIPLY(z4, FIX(1.175875602));
00546                                         z1 = MULTIPLY(d1, -FIX(0.899976223));
00547                                         tmp3 = MULTIPLY(d1, FIX(0.601344887));
00548                                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
00549                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
00550                                         z4 = MULTIPLY(z4, FIX(0.785694958));
00551 
00552                                         tmp0 = z1 + z5;
00553                                         tmp1 += z4;
00554                                         tmp2 = z2 + z5;
00555                                         tmp3 += z4;
00556                                         } 
00557                                         else 
00558                                         {
00559 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
00560                                         tmp0 = MULTIPLY(d5, FIX(1.175875602));
00561                                         tmp1 = MULTIPLY(d5, FIX(0.275899380));
00562                                         tmp2 = MULTIPLY(d5, -FIX(1.387039845));
00563                                         tmp3 = MULTIPLY(d5, FIX(0.785694958));
00564                                         }
00565                         }
00566                         } 
00567                         else 
00568                         {
00569                         if(d3) 
00570                                 {
00571                                         if(d1) 
00572                                         {
00573 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
00574                                         z5 = d1 + d3;
00575                                         tmp3 = MULTIPLY(d1, FIX(0.211164243));
00576                                         tmp2 = MULTIPLY(d3, -FIX(1.451774981));
00577                                         z1 = MULTIPLY(d1, FIX(1.061594337));
00578                                         z2 = MULTIPLY(d3, -FIX(2.172734803));
00579                                         z4 = MULTIPLY(z5, FIX(0.785694958));
00580                                         z5 = MULTIPLY(z5, FIX(1.175875602));
00581 
00582                                         tmp0 = z1 - z4;
00583                                         tmp1 = z2 + z4;
00584                                         tmp2 += z5;
00585                                         tmp3 += z5;
00586                                         } 
00587                                         else 
00588                                         {
00589 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
00590                                         tmp0 = MULTIPLY(d3, -FIX(0.785694958));
00591                                         tmp1 = MULTIPLY(d3, -FIX(1.387039845));
00592                                         tmp2 = MULTIPLY(d3, -FIX(0.275899379));
00593                                         tmp3 = MULTIPLY(d3, FIX(1.175875602));
00594                                         }
00595                         } 
00596                                 else 
00597                                 {
00598                                         if(d1) 
00599                                         {
00600 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
00601                                         tmp0 = MULTIPLY(d1, FIX(0.275899379));
00602                                         tmp1 = MULTIPLY(d1, FIX(0.785694958));
00603                                         tmp2 = MULTIPLY(d1, FIX(1.175875602));
00604                                         tmp3 = MULTIPLY(d1, FIX(1.387039845));
00605                                         } 
00606                                         else 
00607                                         {
00608 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
00609                                         tmp0 = tmp1 = tmp2 = tmp3 = 0;
00610                                         }
00611                         }
00612                         }
00613         }
00614 
00615 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
00616 
00617         dataptr[0] = (int16_t) DESCALE(tmp10 + tmp3, CONST_BITS - PASS1_BITS);
00618         dataptr[7] = (int16_t) DESCALE(tmp10 - tmp3, CONST_BITS - PASS1_BITS);
00619         dataptr[1] = (int16_t) DESCALE(tmp11 + tmp2, CONST_BITS - PASS1_BITS);
00620         dataptr[6] = (int16_t) DESCALE(tmp11 - tmp2, CONST_BITS - PASS1_BITS);
00621         dataptr[2] = (int16_t) DESCALE(tmp12 + tmp1, CONST_BITS - PASS1_BITS);
00622         dataptr[5] = (int16_t) DESCALE(tmp12 - tmp1, CONST_BITS - PASS1_BITS);
00623         dataptr[3] = (int16_t) DESCALE(tmp13 + tmp0, CONST_BITS - PASS1_BITS);
00624         dataptr[4] = (int16_t) DESCALE(tmp13 - tmp0, CONST_BITS - PASS1_BITS);
00625 
00626         dataptr += DCTSIZE1;            /* advance pointer to next row */
00627         }
00628 
00629 /* Pass 2: process columns. */
00630 /* Note that we must descale the results by a factor of 8 == 2**3, */
00631 /* and also undo the PASS1_BITS scaling. */
00632 
00633         dataptr = data;
00634         for(rowctr = DCTSIZE1 - 1; rowctr >= 0; rowctr--) 
00635         {
00636 /* Columns of zeroes can be exploited in the same way as we did with rows.
00637  * However, the row calculation has created many nonzero AC terms, so the
00638  * simplification applies less often (typically 5% to 10% of the time).
00639  * On machines with very fast multiplication, it's possible that the
00640  * test takes more time than it's worth.  In that case this section
00641  * may be commented out.
00642  */
00643 
00644         d0 = dataptr[DCTSIZE1 * 0];
00645         d1 = dataptr[DCTSIZE1 * 1];
00646         d2 = dataptr[DCTSIZE1 * 2];
00647         d3 = dataptr[DCTSIZE1 * 3];
00648         d4 = dataptr[DCTSIZE1 * 4];
00649         d5 = dataptr[DCTSIZE1 * 5];
00650         d6 = dataptr[DCTSIZE1 * 6];
00651         d7 = dataptr[DCTSIZE1 * 7];
00652 
00653 /* Even part: reverse the even part of the forward DCT. */
00654 /* The rotator is sqrt(2)*c(-6). */
00655         if(d6) 
00656                 {
00657                         if(d4) 
00658                         {
00659                         if(d2) 
00660                                 {
00661                                         if(d0) 
00662                                         {
00663 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
00664                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00665                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00666                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00667 
00668                                         tmp0 = (d0 + d4) << CONST_BITS;
00669                                         tmp1 = (d0 - d4) << CONST_BITS;
00670 
00671                                         tmp10 = tmp0 + tmp3;
00672                                         tmp13 = tmp0 - tmp3;
00673                                         tmp11 = tmp1 + tmp2;
00674                                         tmp12 = tmp1 - tmp2;
00675                                         } else {
00676 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
00677                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00678                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00679                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00680 
00681                                         tmp0 = d4 << CONST_BITS;
00682 
00683                                         tmp10 = tmp0 + tmp3;
00684                                         tmp13 = tmp0 - tmp3;
00685                                         tmp11 = tmp2 - tmp0;
00686                                         tmp12 = -(tmp0 + tmp2);
00687                                         }
00688                         } 
00689                                 else 
00690                                 {
00691                                         if(d0) 
00692                                         {
00693 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
00694                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00695                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00696 
00697                                         tmp0 = (d0 + d4) << CONST_BITS;
00698                                         tmp1 = (d0 - d4) << CONST_BITS;
00699 
00700                                         tmp10 = tmp0 + tmp3;
00701                                         tmp13 = tmp0 - tmp3;
00702                                         tmp11 = tmp1 + tmp2;
00703                                         tmp12 = tmp1 - tmp2;
00704                                         } 
00705                                         else 
00706                                         {
00707 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
00708                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00709                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00710 
00711                                         tmp0 = d4 << CONST_BITS;
00712 
00713                                         tmp10 = tmp0 + tmp3;
00714                                         tmp13 = tmp0 - tmp3;
00715                                         tmp11 = tmp2 - tmp0;
00716                                         tmp12 = -(tmp0 + tmp2);
00717                                         }
00718                         }
00719                         } 
00720                         else 
00721                         {
00722                         if(d2) 
00723                                 {
00724                                         if(d0) 
00725                                         {
00726 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
00727                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00728                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00729                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00730 
00731                                         tmp0 = d0 << CONST_BITS;
00732 
00733                                         tmp10 = tmp0 + tmp3;
00734                                         tmp13 = tmp0 - tmp3;
00735                                         tmp11 = tmp0 + tmp2;
00736                                         tmp12 = tmp0 - tmp2;
00737                                         } 
00738                                         else 
00739                                         {
00740 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
00741                                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
00742                                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
00743                                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
00744 
00745                                         tmp10 = tmp3;
00746                                         tmp13 = -tmp3;
00747                                         tmp11 = tmp2;
00748                                         tmp12 = -tmp2;
00749                                         }
00750                         } 
00751                                 else 
00752                                 {
00753                                         if(d0) 
00754                                         {
00755 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
00756                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00757                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00758 
00759                                         tmp0 = d0 << CONST_BITS;
00760 
00761                                         tmp10 = tmp0 + tmp3;
00762                                         tmp13 = tmp0 - tmp3;
00763                                         tmp11 = tmp0 + tmp2;
00764                                         tmp12 = tmp0 - tmp2;
00765                                         } 
00766                                         else 
00767                                         {
00768 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
00769                                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
00770                                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
00771 
00772                                         tmp10 = tmp3;
00773                                         tmp13 = -tmp3;
00774                                         tmp11 = tmp2;
00775                                         tmp12 = -tmp2;
00776                                         }
00777                         }
00778                         }
00779         } 
00780                 else 
00781                 {
00782                         if(d4) 
00783                         {
00784                         if(d2) 
00785                                 {
00786                                         if(d0) 
00787                                         {
00788 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
00789                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00790                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00791 
00792                                         tmp0 = (d0 + d4) << CONST_BITS;
00793                                         tmp1 = (d0 - d4) << CONST_BITS;
00794 
00795                                         tmp10 = tmp0 + tmp3;
00796                                         tmp13 = tmp0 - tmp3;
00797                                         tmp11 = tmp1 + tmp2;
00798                                         tmp12 = tmp1 - tmp2;
00799                                         } 
00800                                         else 
00801                                         {
00802 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
00803                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00804                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00805 
00806                                         tmp0 = d4 << CONST_BITS;
00807 
00808                                         tmp10 = tmp0 + tmp3;
00809                                         tmp13 = tmp0 - tmp3;
00810                                         tmp11 = tmp2 - tmp0;
00811                                         tmp12 = -(tmp0 + tmp2);
00812                                         }
00813                         } 
00814                                 else 
00815                                 {
00816                                         if(d0) 
00817                                         {
00818 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
00819                                         tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
00820                                         tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
00821                                         }
00822                                         else 
00823                                         {
00824 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
00825                                         tmp10 = tmp13 = d4 << CONST_BITS;
00826                                         tmp11 = tmp12 = -tmp10;
00827                                         }
00828                         }
00829                         } 
00830                         else 
00831                         {
00832                         if(d2) 
00833                                 {
00834                                         if(d0) 
00835                                         {
00836 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
00837                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00838                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00839 
00840                                         tmp0 = d0 << CONST_BITS;
00841 
00842                                         tmp10 = tmp0 + tmp3;
00843                                         tmp13 = tmp0 - tmp3;
00844                                         tmp11 = tmp0 + tmp2;
00845                                         tmp12 = tmp0 - tmp2;
00846                                         } 
00847                                         else 
00848                                         {
00849 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
00850                                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
00851                                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
00852 
00853                                         tmp10 = tmp3;
00854                                         tmp13 = -tmp3;
00855                                         tmp11 = tmp2;
00856                                         tmp12 = -tmp2;
00857                                         }
00858                         } 
00859                                 else 
00860                                 {
00861                                         if(d0) 
00862                                         {
00863 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
00864                                         tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
00865                                         } 
00866                                         else 
00867                                         {
00868 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
00869                                         tmp10 = tmp13 = tmp11 = tmp12 = 0;
00870                                         }
00871                         }
00872                         }
00873         }
00874 
00875 /* Odd part per figure 8; the matrix is unitary and hence its
00876  * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
00877  */
00878         if(d7) 
00879                 {
00880                         if(d5) 
00881                         {
00882                         if(d3) 
00883                                 {
00884                                         if(d1) 
00885                                         {
00886 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
00887                                         z1 = d7 + d1;
00888                                         z2 = d5 + d3;
00889                                         z3 = d7 + d3;
00890                                         z4 = d5 + d1;
00891                                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
00892 
00893                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00894                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00895                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00896                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00897                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00898                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
00899                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
00900                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
00901 
00902                                         z3 += z5;
00903                                         z4 += z5;
00904 
00905                                         tmp0 += z1 + z3;
00906                                         tmp1 += z2 + z4;
00907                                         tmp2 += z2 + z3;
00908                                         tmp3 += z1 + z4;
00909                                         } 
00910                                         else 
00911                                         {
00912 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
00913                                         z1 = d7;
00914                                         z2 = d5 + d3;
00915                                         z3 = d7 + d3;
00916                                         z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
00917 
00918                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00919                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00920                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00921                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
00922                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
00923                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
00924                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
00925 
00926                                         z3 += z5;
00927                                         z4 += z5;
00928 
00929                                         tmp0 += z1 + z3;
00930                                         tmp1 += z2 + z4;
00931                                         tmp2 += z2 + z3;
00932                                         tmp3 = z1 + z4;
00933                                         }
00934                         } 
00935                                 else 
00936                                 {
00937                                         if(d1) 
00938                                         {
00939 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
00940                                         z1 = d7 + d1;
00941                                         z2 = d5;
00942                                         z3 = d7;
00943                                         z4 = d5 + d1;
00944                                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
00945 
00946                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00947                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
00948                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00949                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00950                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
00951                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
00952                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
00953 
00954                                         z3 += z5;
00955                                         z4 += z5;
00956 
00957                                         tmp0 += z1 + z3;
00958                                         tmp1 += z2 + z4;
00959                                         tmp2 = z2 + z3;
00960                                         tmp3 += z1 + z4;
00961                                         } 
00962                                         else 
00963                                         {
00964 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
00965                                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
00966                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
00967                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
00968                                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
00969                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
00970                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
00971                                         z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
00972 
00973                                         z3 += z5;
00974                                         z4 += z5;
00975 
00976                                         tmp0 += z3;
00977                                         tmp1 += z4;
00978                                         tmp2 = z2 + z3;
00979                                         tmp3 = z1 + z4;
00980                                         }
00981                         }
00982                         } 
00983                         else 
00984                         {
00985                         if(d3) 
00986                                 {
00987                                         if(d1) 
00988                                         {
00989 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
00990                                         z1 = d7 + d1;
00991                                         z3 = d7 + d3;
00992                                         z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
00993 
00994                                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
00995                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
00996                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
00997                                         z1 = MULTIPLY(z1, -FIX(0.899976223));
00998                                         z2 = MULTIPLY(d3, -FIX(2.562915447));
00999                                         z3 = MULTIPLY(z3, -FIX(1.961570560));
01000                                         z4 = MULTIPLY(d1, -FIX(0.390180644));
01001 
01002                                         z3 += z5;
01003                                         z4 += z5;
01004 
01005                                         tmp0 += z1 + z3;
01006                                         tmp1 = z2 + z4;
01007                                         tmp2 += z2 + z3;
01008                                         tmp3 += z1 + z4;
01009                                         }
01010                                         else 
01011                                         {
01012 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
01013                                         z3 = d7 + d3;
01014 
01015                                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
01016                                         z1 = MULTIPLY(d7, -FIX(0.899976223));
01017                                         tmp2 = MULTIPLY(d3, FIX(0.509795579));
01018                                         z2 = MULTIPLY(d3, -FIX(2.562915447));
01019                                         z5 = MULTIPLY(z3, FIX(1.175875602));
01020                                         z3 = MULTIPLY(z3, -FIX(0.785694958));
01021 
01022                                         tmp0 += z3;
01023                                         tmp1 = z2 + z5;
01024                                         tmp2 += z3;
01025                                         tmp3 = z1 + z5;
01026                                         }
01027                         } 
01028                                 else 
01029                                 {
01030                                         if(d1) 
01031                                         {
01032 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
01033                                         z1 = d7 + d1;
01034                                         z5 = MULTIPLY(z1, FIX(1.175875602));
01035 
01036                                         z1 = MULTIPLY(z1, FIX(0.275899379));
01037                                         z3 = MULTIPLY(d7, -FIX(1.961570560));
01038                                         tmp0 = MULTIPLY(d7, -FIX(1.662939224)); 
01039                                         z4 = MULTIPLY(d1, -FIX(0.390180644));
01040                                         tmp3 = MULTIPLY(d1, FIX(1.111140466));
01041 
01042                                         tmp0 += z1;
01043                                         tmp1 = z4 + z5;
01044                                         tmp2 = z3 + z5;
01045                                         tmp3 += z1;
01046                                         } 
01047                                         else 
01048                                         {
01049 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
01050                                         tmp0 = MULTIPLY(d7, -FIX(1.387039845));
01051                                         tmp1 = MULTIPLY(d7, FIX(1.175875602));
01052                                         tmp2 = MULTIPLY(d7, -FIX(0.785694958));
01053                                         tmp3 = MULTIPLY(d7, FIX(0.275899379));
01054                                         }
01055                         }
01056                         }
01057         } 
01058                 else 
01059                 {
01060                         if(d5)
01061                         {
01062                         if(d3) 
01063                                 {
01064                                         if(d1) 
01065                                         {
01066 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
01067                                         z2 = d5 + d3;
01068                                         z4 = d5 + d1;
01069                                         z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
01070 
01071                                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
01072                                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
01073                                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
01074                                         z1 = MULTIPLY(d1, -FIX(0.899976223));
01075                                         z2 = MULTIPLY(z2, -FIX(2.562915447));
01076                                         z3 = MULTIPLY(d3, -FIX(1.961570560));
01077                                         z4 = MULTIPLY(z4, -FIX(0.390180644));
01078 
01079                                         z3 += z5;
01080                                         z4 += z5;
01081 
01082                                         tmp0 = z1 + z3;
01083                                         tmp1 += z2 + z4;
01084                                         tmp2 += z2 + z3;
01085                                         tmp3 += z1 + z4;
01086                                         } 
01087                                         else 
01088                                         {
01089 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
01090                                         z2 = d5 + d3;
01091 
01092                                         z5 = MULTIPLY(z2, FIX(1.175875602));
01093                                         tmp1 = MULTIPLY(d5, FIX(1.662939225));
01094                                         z4 = MULTIPLY(d5, -FIX(0.390180644));
01095                                         z2 = MULTIPLY(z2, -FIX(1.387039845));
01096                                         tmp2 = MULTIPLY(d3, FIX(1.111140466));
01097                                         z3 = MULTIPLY(d3, -FIX(1.961570560));
01098 
01099                                         tmp0 = z3 + z5;
01100                                         tmp1 += z2;
01101                                         tmp2 += z2;
01102                                         tmp3 = z4 + z5;
01103                                         }
01104                         } 
01105                                 else 
01106                                 {
01107                                         if(d1) 
01108                                         {
01109 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
01110                                         z4 = d5 + d1;
01111 
01112                                         z5 = MULTIPLY(z4, FIX(1.175875602));
01113                                         z1 = MULTIPLY(d1, -FIX(0.899976223));
01114                                         tmp3 = MULTIPLY(d1, FIX(0.601344887));
01115                                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
01116                                         z2 = MULTIPLY(d5, -FIX(2.562915447));
01117                                         z4 = MULTIPLY(z4, FIX(0.785694958));
01118 
01119                                         tmp0 = z1 + z5;
01120                                         tmp1 += z4;
01121                                         tmp2 = z2 + z5;
01122                                         tmp3 += z4;
01123                                         } 
01124                                         else 
01125                                         {
01126 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
01127                                         tmp0 = MULTIPLY(d5, FIX(1.175875602));
01128                                         tmp1 = MULTIPLY(d5, FIX(0.275899380));
01129                                         tmp2 = MULTIPLY(d5, -FIX(1.387039845));
01130                                         tmp3 = MULTIPLY(d5, FIX(0.785694958));
01131                                         }
01132                                 }
01133                         } 
01134                         else 
01135                         {
01136                         if(d3) 
01137                                 {
01138                                         if(d1) 
01139                                         {
01140 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
01141                                         z5 = d1 + d3;
01142                                         tmp3 = MULTIPLY(d1, FIX(0.211164243));
01143                                         tmp2 = MULTIPLY(d3, -FIX(1.451774981));
01144                                         z1 = MULTIPLY(d1, FIX(1.061594337));
01145                                         z2 = MULTIPLY(d3, -FIX(2.172734803));
01146                                         z4 = MULTIPLY(z5, FIX(0.785694958));
01147                                         z5 = MULTIPLY(z5, FIX(1.175875602));
01148 
01149                                         tmp0 = z1 - z4;
01150                                         tmp1 = z2 + z4;
01151                                         tmp2 += z5;
01152                                         tmp3 += z5;
01153                                         } 
01154                                         else 
01155                                         {
01156 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
01157                                         tmp0 = MULTIPLY(d3, -FIX(0.785694958));
01158                                         tmp1 = MULTIPLY(d3, -FIX(1.387039845));
01159                                         tmp2 = MULTIPLY(d3, -FIX(0.275899379));
01160                                         tmp3 = MULTIPLY(d3, FIX(1.175875602));
01161                                         }
01162                         } 
01163                                 else 
01164                                 {
01165                                         if(d1) 
01166                                         {
01167 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
01168                                         tmp0 = MULTIPLY(d1, FIX(0.275899379));
01169                                         tmp1 = MULTIPLY(d1, FIX(0.785694958));
01170                                         tmp2 = MULTIPLY(d1, FIX(1.175875602));
01171                                         tmp3 = MULTIPLY(d1, FIX(1.387039845));
01172                                         } 
01173                                         else 
01174                                         {
01175 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
01176                                         tmp0 = tmp1 = tmp2 = tmp3 = 0;
01177                                         }
01178                         }
01179                         }
01180         }
01181 
01182 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
01183 
01184 
01185                 outptr[DCTSIZE1 * 0] = rnglimit[(int)DESCALE(tmp10 + tmp3, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01186                 outptr[DCTSIZE1 * 7] = rnglimit[(int)DESCALE(tmp10 - tmp3, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01187                 outptr[DCTSIZE1 * 1] = rnglimit[(int)DESCALE(tmp11 + tmp2, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01188                 outptr[DCTSIZE1 * 6] = rnglimit[(int)DESCALE(tmp11 - tmp2, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01189                 outptr[DCTSIZE1 * 2] = rnglimit[(int)DESCALE(tmp12 + tmp1, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01190                 outptr[DCTSIZE1 * 5] = rnglimit[(int)DESCALE(tmp12 - tmp1, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01191                 outptr[DCTSIZE1 * 3] = rnglimit[(int)DESCALE(tmp13 + tmp0, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01192                 outptr[DCTSIZE1 * 4] = rnglimit[(int)DESCALE(tmp13 - tmp0, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
01193 
01194                 dataptr++;                      /* advance pointer to next column */
01195                 outptr++;
01196         }
01197 }