git.sesse.net Git - vlc/blob - plugins/idct/idct.c

   1 /*****************************************************************************
   2  * idct.c : C IDCT module
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: idct.c,v 1.19 2001/12/30 07:09:55 sam Exp $
   6  *
   7  * Author: Gaël Hendryckx <jimmy@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include <videolan/vlc.h>
  31
  32 #include "idct.h"
  33 #include "block_c.h"
  34
  35 /*****************************************************************************
  36  * Local and extern prototypes.
  37  *****************************************************************************/
  38 static void idct_getfunctions( function_list_t * p_function_list );
  39
  40 /*****************************************************************************
  41  * Build configuration tree.
  42  *****************************************************************************/
  43 MODULE_CONFIG_START
  44 MODULE_CONFIG_STOP
  45
  46 MODULE_INIT_START
  47     SET_DESCRIPTION( "IDCT module" )
  48     ADD_CAPABILITY( IDCT, 50 )
  49     ADD_SHORTCUT( "c" )
  50     ADD_SHORTCUT( "idct" )
  51 MODULE_INIT_STOP
  52
  53 MODULE_ACTIVATE_START
  54     idct_getfunctions( &p_module->p_functions->idct );
  55 MODULE_ACTIVATE_STOP
  56
  57 MODULE_DEACTIVATE_START
  58 MODULE_DEACTIVATE_STOP
  59
  60 /* Following functions are local */
  61
  62 /*****************************************************************************
  63  * idct_Probe: returns a preference score
  64  *****************************************************************************/
  65 static int idct_Probe( probedata_t *p_data )
  66 {
  67     return( 50 );
  68 }
  69
  70 /*****************************************************************************
  71  * NormScan : Unused in this IDCT
  72  *****************************************************************************/
  73 static void NormScan( u8 ppi_scan[2][64] )
  74 {
  75 }
  76
  77 /*****************************************************************************
  78  * IDCT : IDCT function for normal matrices
  79  *****************************************************************************/
  80 static __inline__ void IDCT( dctelem_t * p_block )
  81 {
  82     s32 tmp0, tmp1, tmp2, tmp3;
  83     s32 tmp10, tmp11, tmp12, tmp13;
  84     s32 z1, z2, z3, z4, z5;
  85     s32 d0, d1, d2, d3, d4, d5, d6, d7;
  86     dctelem_t * dataptr;
  87     int rowctr;
  88
  89     SHIFT_TEMPS
  90
  91     /* Pass 1: process rows. */
  92     /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  93     /* furthermore, we scale the results by 2**PASS1_BITS. */
  94
  95     dataptr = p_block;
  96
  97     for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
  98     {
  99         /* Due to quantization, we will usually find that many of the input
 100          * coefficients are zero, especially the AC terms.  We can exploit this
 101          * by short-circuiting the IDCT calculation for any row in which all
 102          * the AC terms are zero.  In that case each output is equal to the
 103          * DC coefficient (with scale factor as needed).
 104          * With typical images and quantization tables, half or more of the
 105          * row DCT calculations can be simplified this way.
 106          */
 107
 108         register int * idataptr = (int*)dataptr;
 109         d0 = dataptr[0];
 110         d1 = dataptr[1];
 111         if ( (d1 == 0) && ((idataptr[1] | idataptr[2] | idataptr[3]) == 0) )
 112         {
 113       /* AC terms all zero */
 114             if (d0)
 115             {
 116       /* Compute a 32 bit value to assign. */
 117                 dctelem_t dcval = (dctelem_t) (d0 << PASS1_BITS);
 118                 register int v = (dcval & 0xffff) | (dcval << 16);
 119
 120                 idataptr[0] = v;
 121                 idataptr[1] = v;
 122                 idataptr[2] = v;
 123                 idataptr[3] = v;
 124             }
 125
 126             dataptr += DCTSIZE; /* advance pointer to next row */
 127             continue;
 128         }
 129         d2 = dataptr[2];
 130         d3 = dataptr[3];
 131         d4 = dataptr[4];
 132         d5 = dataptr[5];
 133         d6 = dataptr[6];
 134         d7 = dataptr[7];
 135
 136     /* Even part: reverse the even part of the forward DCT. */
 137     /* The rotator is sqrt(2)*c(-6). */
 138         if (d6)
 139         {
 140             if (d4)
 141             {
 142                 if (d2)
 143                 {
 144                     if (d0)
 145                     {
 146             /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
 147                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 148                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 149                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 150
 151                         tmp0 = (d0 + d4) << CONST_BITS;
 152                         tmp1 = (d0 - d4) << CONST_BITS;
 153
 154                         tmp10 = tmp0 + tmp3;
 155                         tmp13 = tmp0 - tmp3;
 156                         tmp11 = tmp1 + tmp2;
 157                         tmp12 = tmp1 - tmp2;
 158                     }
 159                     else
 160                     {
 161                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
 162                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 163                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 164                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 165
 166                         tmp0 = d4 << CONST_BITS;
 167
 168                         tmp10 = tmp0 + tmp3;
 169                         tmp13 = tmp0 - tmp3;
 170                         tmp11 = tmp2 - tmp0;
 171                         tmp12 = -(tmp0 + tmp2);
 172                         }
 173                 }
 174                 else
 175                 {
 176                     if (d0)
 177                     {
 178             /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
 179                         tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 180                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 181
 182                         tmp0 = (d0 + d4) << CONST_BITS;
 183                         tmp1 = (d0 - d4) << CONST_BITS;
 184
 185                         tmp10 = tmp0 + tmp3;
 186                         tmp13 = tmp0 - tmp3;
 187                         tmp11 = tmp1 + tmp2;
 188                         tmp12 = tmp1 - tmp2;
 189                         }
 190                     else
 191                     {
 192                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
 193                         tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 194                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 195
 196                         tmp0 = d4 << CONST_BITS;
 197
 198                         tmp10 = tmp0 + tmp3;
 199                         tmp13 = tmp0 - tmp3;
 200                         tmp11 = tmp2 - tmp0;
 201                         tmp12 = -(tmp0 + tmp2);
 202                         }
 203                 }
 204             }
 205             else
 206             {
 207                 if (d2)
 208                 {
 209                     if (d0)
 210                     {
 211             /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
 212                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 213                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 214                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 215
 216                         tmp0 = d0 << CONST_BITS;
 217
 218                         tmp10 = tmp0 + tmp3;
 219                         tmp13 = tmp0 - tmp3;
 220                         tmp11 = tmp0 + tmp2;
 221                         tmp12 = tmp0 - tmp2;
 222                     }
 223                     else
 224                     {
 225                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
 226                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 227                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 228                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 229
 230                         tmp10 = tmp3;
 231                         tmp13 = -tmp3;
 232                         tmp11 = tmp2;
 233                         tmp12 = -tmp2;
 234                             }
 235                 }
 236                 else
 237                 {
 238                     if (d0)
 239                     {
 240             /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
 241                         tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 242                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 243
 244                         tmp0 = d0 << CONST_BITS;
 245
 246                         tmp10 = tmp0 + tmp3;
 247                         tmp13 = tmp0 - tmp3;
 248                         tmp11 = tmp0 + tmp2;
 249                         tmp12 = tmp0 - tmp2;
 250                     }
 251                     else
 252                     {
 253             /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
 254                         tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 255                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 256
 257                         tmp10 = tmp3;
 258                         tmp13 = -tmp3;
 259                         tmp11 = tmp2;
 260                         tmp12 = -tmp2;
 261                     }
 262                 }
 263             }
 264         }
 265         else
 266         {
 267             if (d4)
 268             {
 269                 if (d2)
 270                 {
 271                     if (d0)
 272                     {
 273                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
 274                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
 275                         tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 276
 277                         tmp0 = (d0 + d4) << CONST_BITS;
 278                         tmp1 = (d0 - d4) << CONST_BITS;
 279
 280                         tmp10 = tmp0 + tmp3;
 281                         tmp13 = tmp0 - tmp3;
 282                         tmp11 = tmp1 + tmp2;
 283                         tmp12 = tmp1 - tmp2;
 284                     }
 285                     else
 286                     {
 287             /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
 288                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
 289                         tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 290
 291                         tmp0 = d4 << CONST_BITS;
 292
 293                         tmp10 = tmp0 + tmp3;
 294                         tmp13 = tmp0 - tmp3;
 295                         tmp11 = tmp2 - tmp0;
 296                         tmp12 = -(tmp0 + tmp2);
 297                     }
 298                 }
 299                 else
 300                 {
 301                     if (d0)
 302                     {
 303             /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
 304                         tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
 305                         tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
 306                     }
 307                     else
 308                     {
 309             /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
 310                         tmp10 = tmp13 = d4 << CONST_BITS;
 311                         tmp11 = tmp12 = -tmp10;
 312                     }
 313                 }
 314             }
 315             else
 316             {
 317                 if (d2)
 318                 {
 319                     if (d0)
 320                     {
 321             /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
 322                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
 323                         tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 324
 325                         tmp0 = d0 << CONST_BITS;
 326
 327                         tmp10 = tmp0 + tmp3;
 328                         tmp13 = tmp0 - tmp3;
 329                         tmp11 = tmp0 + tmp2;
 330                         tmp12 = tmp0 - tmp2;
 331                     }
 332                     else
 333                     {
 334             /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
 335                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
 336                         tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 337
 338                         tmp10 = tmp3;
 339                         tmp13 = -tmp3;
 340                         tmp11 = tmp2;
 341                         tmp12 = -tmp2;
 342                     }
 343                 }
 344                 else
 345                 {
 346                     if (d0)
 347                     {
 348             /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
 349                         tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
 350                     }
 351                     else
 352                     {
 353             /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
 354                         tmp10 = tmp13 = tmp11 = tmp12 = 0;
 355                     }
 356                 }
 357             }
 358         }
 359
 360
 361     /* Odd part per figure 8; the matrix is unitary and hence its
 362      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
 363      */
 364
 365         if (d7)
 366             {
 367             if (d5)
 368             {
 369                 if (d3)
 370                 {
 371                     if (d1)
 372                     {
 373             /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
 374                         z1 = d7 + d1;
 375                         z2 = d5 + d3;
 376                         z3 = d7 + d3;
 377                         z4 = d5 + d1;
 378                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
 379
 380                         tmp0 = MULTIPLY(d7, FIX(0.298631336));
 381                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
 382                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
 383                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
 384                         z1 = MULTIPLY(z1, - FIX(0.899976223));
 385                         z2 = MULTIPLY(z2, - FIX(2.562915447));
 386                         z3 = MULTIPLY(z3, - FIX(1.961570560));
 387                         z4 = MULTIPLY(z4, - FIX(0.390180644));
 388
 389                         z3 += z5;
 390                         z4 += z5;
 391
 392                         tmp0 += z1 + z3;
 393                         tmp1 += z2 + z4;
 394                         tmp2 += z2 + z3;
 395                         tmp3 += z1 + z4;
 396                     }
 397                     else
 398                     {
 399             /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
 400                         z2 = d5 + d3;
 401                         z3 = d7 + d3;
 402                         z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
 403
 404                         tmp0 = MULTIPLY(d7, FIX(0.298631336));
 405                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
 406                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
 407                         z1 = MULTIPLY(d7, - FIX(0.899976223));
 408                         z2 = MULTIPLY(z2, - FIX(2.562915447));
 409                         z3 = MULTIPLY(z3, - FIX(1.961570560));
 410                         z4 = MULTIPLY(d5, - FIX(0.390180644));
 411
 412                         z3 += z5;
 413                         z4 += z5;
 414
 415                         tmp0 += z1 + z3;
 416                         tmp1 += z2 + z4;
 417                         tmp2 += z2 + z3;
 418                         tmp3 = z1 + z4;
 419                         }
 420                     }
 421                 else
 422                 {
 423                     if (d1)
 424                     {
 425             /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
 426                         z1 = d7 + d1;
 427                         z4 = d5 + d1;
 428                         z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
 429
 430                         tmp0 = MULTIPLY(d7, FIX(0.298631336));
 431                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
 432                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
 433                         z1 = MULTIPLY(z1, - FIX(0.899976223));
 434                         z2 = MULTIPLY(d5, - FIX(2.562915447));
 435                         z3 = MULTIPLY(d7, - FIX(1.961570560));
 436                         z4 = MULTIPLY(z4, - FIX(0.390180644));
 437
 438                         z3 += z5;
 439                         z4 += z5;
 440
 441                         tmp0 += z1 + z3;
 442                         tmp1 += z2 + z4;
 443                         tmp2 = z2 + z3;
 444                         tmp3 += z1 + z4;
 445                     }
 446                     else
 447                     {
 448             /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
 449                         z5 = MULTIPLY(d7 + d5, FIX(1.175875602));
 450
 451                         tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
 452                         tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
 453                         z1 = MULTIPLY(d7, - FIX(0.899976223));
 454                         z3 = MULTIPLY(d7, - FIX(1.961570560));
 455                         z2 = MULTIPLY(d5, - FIX(2.562915447));
 456                         z4 = MULTIPLY(d5, - FIX(0.390180644));
 457
 458                         z3 += z5;
 459                         z4 += z5;
 460
 461                         tmp0 += z3;
 462                         tmp1 += z4;
 463                         tmp2 = z2 + z3;
 464                         tmp3 = z1 + z4;
 465                     }
 466                 }
 467             }
 468             else
 469             {
 470                 if (d3)
 471                 {
 472                     if (d1)
 473                     {
 474             /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
 475                         z1 = d7 + d1;
 476                         z3 = d7 + d3;
 477                         z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
 478
 479                         tmp0 = MULTIPLY(d7, FIX(0.298631336));
 480                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
 481                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
 482                         z1 = MULTIPLY(z1, - FIX(0.899976223));
 483                         z2 = MULTIPLY(d3, - FIX(2.562915447));
 484                         z3 = MULTIPLY(z3, - FIX(1.961570560));
 485                         z4 = MULTIPLY(d1, - FIX(0.390180644));
 486
 487                         z3 += z5;
 488                         z4 += z5;
 489
 490                         tmp0 += z1 + z3;
 491                         tmp1 = z2 + z4;
 492                         tmp2 += z2 + z3;
 493                         tmp3 += z1 + z4;
 494                     }
 495                     else
 496                     {
 497             /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
 498                         z3 = d7 + d3;
 499                         z5 = MULTIPLY(z3, FIX(1.175875602));
 500
 501                         tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
 502                         tmp2 = MULTIPLY(d3, FIX(0.509795579));
 503                         z1 = MULTIPLY(d7, - FIX(0.899976223));
 504                         z2 = MULTIPLY(d3, - FIX(2.562915447));
 505                         z3 = MULTIPLY(z3, - FIX2(0.785694958));
 506
 507                         tmp0 += z3;
 508                         tmp1 = z2 + z5;
 509                         tmp2 += z3;
 510                         tmp3 = z1 + z5;
 511                     }
 512                 }
 513                 else
 514                 {
 515                     if (d1)
 516                     {
 517             /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
 518                         z1 = d7 + d1;
 519                         z5 = MULTIPLY(z1, FIX(1.175875602));
 520
 521                         tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
 522                         tmp3 = MULTIPLY(d1, FIX2(1.111140466));
 523                         z1 = MULTIPLY(z1, FIX2(0.275899379));
 524                         z3 = MULTIPLY(d7, - FIX(1.961570560));
 525                         z4 = MULTIPLY(d1, - FIX(0.390180644));
 526
 527                         tmp0 += z1;
 528                         tmp1 = z4 + z5;
 529                         tmp2 = z3 + z5;
 530                         tmp3 += z1;
 531                     }
 532                 else
 533                     {
 534             /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
 535                         tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
 536                         tmp1 = MULTIPLY(d7, FIX(1.175875602));
 537                         tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
 538                         tmp3 = MULTIPLY(d7, FIX2(0.275899379));
 539                     }
 540                 }
 541             }
 542         }
 543         else
 544         {
 545             if (d5)
 546             {
 547                 if (d3)
 548                 {
 549                     if (d1)
 550                     {
 551             /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
 552                         z2 = d5 + d3;
 553                         z4 = d5 + d1;
 554                         z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
 555
 556                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
 557                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
 558                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
 559                         z1 = MULTIPLY(d1, - FIX(0.899976223));
 560                         z2 = MULTIPLY(z2, - FIX(2.562915447));
 561                         z3 = MULTIPLY(d3, - FIX(1.961570560));
 562                         z4 = MULTIPLY(z4, - FIX(0.390180644));
 563
 564                         z3 += z5;
 565                         z4 += z5;
 566
 567                         tmp0 = z1 + z3;
 568                         tmp1 += z2 + z4;
 569                         tmp2 += z2 + z3;
 570                         tmp3 += z1 + z4;
 571                     }
 572                     else
 573                     {
 574             /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
 575                         z2 = d5 + d3;
 576                         z5 = MULTIPLY(z2, FIX(1.175875602));
 577
 578                         tmp1 = MULTIPLY(d5, FIX2(1.662939225));
 579                         tmp2 = MULTIPLY(d3, FIX2(1.111140466));
 580                         z2 = MULTIPLY(z2, - FIX2(1.387039845));
 581                         z3 = MULTIPLY(d3, - FIX(1.961570560));
 582                         z4 = MULTIPLY(d5, - FIX(0.390180644));
 583
 584                         tmp0 = z3 + z5;
 585                         tmp1 += z2;
 586                         tmp2 += z2;
 587                         tmp3 = z4 + z5;
 588                     }
 589                 }
 590                 else
 591                 {
 592                     if (d1)
 593                     {
 594             /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
 595                         z4 = d5 + d1;
 596                         z5 = MULTIPLY(z4, FIX(1.175875602));
 597
 598                         tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
 599                         tmp3 = MULTIPLY(d1, FIX2(0.601344887));
 600                         z1 = MULTIPLY(d1, - FIX(0.899976223));
 601                         z2 = MULTIPLY(d5, - FIX(2.562915447));
 602                         z4 = MULTIPLY(z4, FIX2(0.785694958));
 603
 604                         tmp0 = z1 + z5;
 605                         tmp1 += z4;
 606                         tmp2 = z2 + z5;
 607                         tmp3 += z4;
 608                     }
 609                     else
 610                     {
 611             /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
 612                         tmp0 = MULTIPLY(d5, FIX(1.175875602));
 613                         tmp1 = MULTIPLY(d5, FIX2(0.275899380));
 614                         tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
 615                         tmp3 = MULTIPLY(d5, FIX2(0.785694958));
 616                     }
 617                 }
 618             }
 619             else
 620             {
 621                 if (d3)
 622                 {
 623                     if (d1)
 624                     {
 625             /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
 626                         z5 = d3 + d1;
 627
 628                         tmp2 = MULTIPLY(d3, - FIX(1.451774981));
 629                         tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
 630                         z1 = MULTIPLY(d1, FIX(1.061594337));
 631                         z2 = MULTIPLY(d3, - FIX(2.172734803));
 632                         z4 = MULTIPLY(z5, FIX(0.785694958));
 633                         z5 = MULTIPLY(z5, FIX(1.175875602));
 634
 635                         tmp0 = z1 - z4;
 636                         tmp1 = z2 + z4;
 637                         tmp2 += z5;
 638                         tmp3 += z5;
 639                     }
 640                     else
 641                     {
 642             /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
 643                         tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
 644                         tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
 645                         tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
 646                         tmp3 = MULTIPLY(d3, FIX(1.175875602));
 647                     }
 648                 }
 649                 else
 650                 {
 651                     if (d1)
 652                     {
 653             /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
 654                         tmp0 = MULTIPLY(d1, FIX2(0.275899379));
 655                         tmp1 = MULTIPLY(d1, FIX2(0.785694958));
 656                         tmp2 = MULTIPLY(d1, FIX(1.175875602));
 657                         tmp3 = MULTIPLY(d1, FIX2(1.387039845));
 658                     }
 659                     else
 660                     {
 661             /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
 662                         tmp0 = tmp1 = tmp2 = tmp3 = 0;
 663                     }
 664                 }
 665             }
 666         }
 667
 668     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
 669
 670         dataptr[0] = (dctelem_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
 671         dataptr[7] = (dctelem_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
 672         dataptr[1] = (dctelem_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
 673         dataptr[6] = (dctelem_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
 674         dataptr[2] = (dctelem_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
 675         dataptr[5] = (dctelem_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
 676         dataptr[3] = (dctelem_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
 677         dataptr[4] = (dctelem_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
 678
 679         dataptr += DCTSIZE;              /* advance pointer to next row */
 680     }
 681
 682   /* Pass 2: process columns. */
 683   /* Note that we must descale the results by a factor of 8 == 2**3, */
 684   /* and also undo the PASS1_BITS scaling. */
 685
 686     dataptr = p_block;
 687     for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
 688     {
 689     /* Columns of zeroes can be exploited in the same way as we did with rows.
 690      * However, the row calculation has created many nonzero AC terms, so the
 691      * simplification applies less often (typically 5% to 10% of the time).
 692      * On machines with very fast multiplication, it's possible that the
 693      * test takes more time than it's worth.  In that case this section
 694      * may be commented out.
 695      */
 696
 697         d0 = dataptr[DCTSIZE*0];
 698         d1 = dataptr[DCTSIZE*1];
 699         d2 = dataptr[DCTSIZE*2];
 700         d3 = dataptr[DCTSIZE*3];
 701         d4 = dataptr[DCTSIZE*4];
 702         d5 = dataptr[DCTSIZE*5];
 703         d6 = dataptr[DCTSIZE*6];
 704         d7 = dataptr[DCTSIZE*7];
 705
 706     /* Even part: reverse the even part of the forward DCT. */
 707     /* The rotator is sqrt(2)*c(-6). */
 708         if (d6)
 709         {
 710             if (d4)
 711             {
 712                 if (d2)
 713                 {
 714                     if (d0)
 715                     {
 716             /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
 717                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 718                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 719                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 720
 721                         tmp0 = (d0 + d4) << CONST_BITS;
 722                         tmp1 = (d0 - d4) << CONST_BITS;
 723
 724                         tmp10 = tmp0 + tmp3;
 725                         tmp13 = tmp0 - tmp3;
 726                         tmp11 = tmp1 + tmp2;
 727                         tmp12 = tmp1 - tmp2;
 728                     }
 729                     else
 730                     {
 731             /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
 732                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 733                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 734                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 735
 736                         tmp0 = d4 << CONST_BITS;
 737
 738                         tmp10 = tmp0 + tmp3;
 739                         tmp13 = tmp0 - tmp3;
 740                         tmp11 = tmp2 - tmp0;
 741                         tmp12 = -(tmp0 + tmp2);
 742                     }
 743                 }
 744                 else
 745                 {
 746                     if (d0)
 747                     {
 748             /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
 749                         tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 750                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 751
 752                         tmp0 = (d0 + d4) << CONST_BITS;
 753                         tmp1 = (d0 - d4) << CONST_BITS;
 754
 755                         tmp10 = tmp0 + tmp3;
 756                         tmp13 = tmp0 - tmp3;
 757                         tmp11 = tmp1 + tmp2;
 758                         tmp12 = tmp1 - tmp2;
 759                     }
 760                     else
 761                     {
 762             /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
 763                         tmp2 = MULTIPLY(d6, -FIX2(1.306562965));
 764                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
 765
 766                         tmp0 = d4 << CONST_BITS;
 767
 768                         tmp10 = tmp0 + tmp3;
 769                         tmp13 = tmp0 - tmp3;
 770                         tmp11 = tmp2 - tmp0;
 771                         tmp12 = -(tmp0 + tmp2);
 772                     }
 773                 }
 774             }
 775             else
 776             {
 777                 if (d2)
 778                 {
 779                     if (d0)
 780                     {
 781             /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
 782                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 783                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 784                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 785
 786                         tmp0 = d0 << CONST_BITS;
 787
 788                         tmp10 = tmp0 + tmp3;
 789                         tmp13 = tmp0 - tmp3;
 790                         tmp11 = tmp0 + tmp2;
 791                         tmp12 = tmp0 - tmp2;
 792                     }
 793                     else
 794                     {
 795             /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
 796                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
 797                         tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
 798                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
 799
 800                         tmp10 = tmp3;
 801                         tmp13 = -tmp3;
 802                         tmp11 = tmp2;
 803                         tmp12 = -tmp2;
 804                     }
 805                 }
 806                 else
 807                 {
 808                     if (d0)
 809                     {
 810             /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
 811                     tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 812                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
 813
 814                     tmp0 = d0 << CONST_BITS;
 815
 816                     tmp10 = tmp0 + tmp3;
 817                     tmp13 = tmp0 - tmp3;
 818                     tmp11 = tmp0 + tmp2;
 819                     tmp12 = tmp0 - tmp2;
 820                 }
 821                 else
 822                 {
 823             /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
 824                     tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
 825                     tmp3 = MULTIPLY(d6, FIX(0.541196100));
 826                     tmp10 = tmp3;
 827                     tmp13 = -tmp3;
 828                     tmp11 = tmp2;
 829                     tmp12 = -tmp2;
 830                 }
 831             }
 832         }
 833     }
 834     else
 835     {
 836         if (d4)
 837         {
 838             if (d2)
 839             {
 840                 if (d0)
 841                 {
 842             /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
 843                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
 844                     tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 845
 846                     tmp0 = (d0 + d4) << CONST_BITS;
 847                     tmp1 = (d0 - d4) << CONST_BITS;
 848
 849                     tmp10 = tmp0 + tmp3;
 850                     tmp13 = tmp0 - tmp3;
 851                     tmp11 = tmp1 + tmp2;
 852                     tmp12 = tmp1 - tmp2;
 853                 }
 854                 else
 855                 {
 856             /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
 857                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
 858                     tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 859
 860                     tmp0 = d4 << CONST_BITS;
 861
 862                     tmp10 = tmp0 + tmp3;
 863                     tmp13 = tmp0 - tmp3;
 864                     tmp11 = tmp2 - tmp0;
 865                     tmp12 = -(tmp0 + tmp2);
 866                 }
 867             }
 868             else
 869             {
 870                 if (d0)
 871                 {
 872             /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
 873                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
 874                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
 875                 }
 876                 else
 877                 {
 878             /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
 879                     tmp10 = tmp13 = d4 << CONST_BITS;
 880                     tmp11 = tmp12 = -tmp10;
 881                 }
 882             }
 883         }
 884         else
 885         {
 886         if (d2)
 887         {
 888             if (d0)
 889             {
 890             /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
 891                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
 892                     tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 893
 894                     tmp0 = d0 << CONST_BITS;
 895
 896                     tmp10 = tmp0 + tmp3;
 897                     tmp13 = tmp0 - tmp3;
 898                     tmp11 = tmp0 + tmp2;
 899                     tmp12 = tmp0 - tmp2;
 900             }
 901             else
 902             {
 903             /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
 904                     tmp2 = MULTIPLY(d2, FIX(0.541196100));
 905                     tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
 906
 907                     tmp10 = tmp3;
 908                     tmp13 = -tmp3;
 909                     tmp11 = tmp2;
 910                     tmp12 = -tmp2;
 911             }
 912         }
 913         else
 914         {
 915             if (d0)
 916                 {
 917             /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
 918                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
 919                 }
 920                 else
 921                 {
 922             /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
 923                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
 924                 }
 925             }
 926         }
 927     }
 928
 929     /* Odd part per figure 8; the matrix is unitary and hence its
 930      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
 931      */
 932     if (d7)
 933     {
 934         if (d5)
 935         {
 936             if (d3)
 937             {
 938                 if (d1)
 939                 {
 940             /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
 941                     z1 = d7 + d1;
 942                     z2 = d5 + d3;
 943                     z3 = d7 + d3;
 944                     z4 = d5 + d1;
 945                     z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
 946
 947                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
 948                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
 949                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
 950                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
 951                     z1 = MULTIPLY(z1, - FIX(0.899976223));
 952                     z2 = MULTIPLY(z2, - FIX(2.562915447));
 953                     z3 = MULTIPLY(z3, - FIX(1.961570560));
 954                     z4 = MULTIPLY(z4, - FIX(0.390180644));
 955
 956                     z3 += z5;
 957                     z4 += z5;
 958
 959                     tmp0 += z1 + z3;
 960                     tmp1 += z2 + z4;
 961                     tmp2 += z2 + z3;
 962                     tmp3 += z1 + z4;
 963                 }
 964                 else
 965                 {
 966             /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
 967                     z2 = d5 + d3;
 968                     z3 = d7 + d3;
 969                     z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
 970
 971                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
 972                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
 973                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
 974                     z1 = MULTIPLY(d7, - FIX(0.899976223));
 975                     z2 = MULTIPLY(z2, - FIX(2.562915447));
 976                     z3 = MULTIPLY(z3, - FIX(1.961570560));
 977                     z4 = MULTIPLY(d5, - FIX(0.390180644));
 978
 979                     z3 += z5;
 980                     z4 += z5;
 981
 982                     tmp0 += z1 + z3;
 983                     tmp1 += z2 + z4;
 984                     tmp2 += z2 + z3;
 985                     tmp3 = z1 + z4;
 986                 }
 987             }
 988             else
 989             {
 990                 if (d1)
 991                 {
 992             /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
 993                     z1 = d7 + d1;
 994                     z4 = d5 + d1;
 995                     z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
 996
 997                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
 998                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
 999                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
1000                     z1 = MULTIPLY(z1, - FIX(0.899976223));
1001                     z2 = MULTIPLY(d5, - FIX(2.562915447));
1002                     z3 = MULTIPLY(d7, - FIX(1.961570560));
1003                     z4 = MULTIPLY(z4, - FIX(0.390180644));
1004
1005                     z3 += z5;
1006                     z4 += z5;
1007
1008                     tmp0 += z1 + z3;
1009                     tmp1 += z2 + z4;
1010                     tmp2 = z2 + z3;
1011                     tmp3 += z1 + z4;
1012                 }
1013                 else
1014                 {
1015             /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
1016                     z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
1017
1018                     tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1019                     tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1020                     z1 = MULTIPLY(d7, - FIX(0.899976223));
1021                     z3 = MULTIPLY(d7, - FIX(1.961570560));
1022                     z2 = MULTIPLY(d5, - FIX(2.562915447));
1023                     z4 = MULTIPLY(d5, - FIX(0.390180644));
1024
1025                     z3 += z5;
1026                     z4 += z5;
1027
1028                     tmp0 += z3;
1029                     tmp1 += z4;
1030                     tmp2 = z2 + z3;
1031                     tmp3 = z1 + z4;
1032                 }
1033             }
1034         }
1035         else
1036         {
1037             if (d3)
1038             {
1039                 if (d1)
1040                 {
1041             /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
1042                     z1 = d7 + d1;
1043                     z3 = d7 + d3;
1044                     z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
1045
1046                     tmp0 = MULTIPLY(d7, FIX(0.298631336));
1047                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
1048                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
1049                     z1 = MULTIPLY(z1, - FIX(0.899976223));
1050                     z2 = MULTIPLY(d3, - FIX(2.562915447));
1051                     z3 = MULTIPLY(z3, - FIX(1.961570560));
1052                     z4 = MULTIPLY(d1, - FIX(0.390180644));
1053
1054                     z3 += z5;
1055                     z4 += z5;
1056
1057                     tmp0 += z1 + z3;
1058                     tmp1 = z2 + z4;
1059                     tmp2 += z2 + z3;
1060                     tmp3 += z1 + z4;
1061                 }
1062                 else
1063                 {
1064             /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
1065                     z3 = d7 + d3;
1066                     z5 = MULTIPLY(z3, FIX(1.175875602));
1067
1068                     tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1069                     z1 = MULTIPLY(d7, - FIX(0.899976223));
1070                     tmp2 = MULTIPLY(d3, FIX(0.509795579));
1071                     z2 = MULTIPLY(d3, - FIX(2.562915447));
1072                     z3 = MULTIPLY(z3, - FIX2(0.785694958));
1073
1074                     tmp0 += z3;
1075                     tmp1 = z2 + z5;
1076                     tmp2 += z3;
1077                     tmp3 = z1 + z5;
1078                 }
1079             }
1080             else
1081             {
1082                 if (d1)
1083                 {
1084             /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
1085                     z1 = d7 + d1;
1086                     z5 = MULTIPLY(z1, FIX(1.175875602));
1087
1088                     tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
1089                     tmp3 = MULTIPLY(d1, FIX2(1.111140466));
1090                     z1 = MULTIPLY(z1, FIX2(0.275899379));
1091                     z3 = MULTIPLY(d7, - FIX(1.961570560));
1092                     z4 = MULTIPLY(d1, - FIX(0.390180644));
1093
1094                     tmp0 += z1;
1095                     tmp1 = z4 + z5;
1096                     tmp2 = z3 + z5;
1097                     tmp3 += z1;
1098                 }
1099                 else
1100                 {
1101             /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
1102                     tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
1103                     tmp1 = MULTIPLY(d7, FIX(1.175875602));
1104                     tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
1105                     tmp3 = MULTIPLY(d7, FIX2(0.275899379));
1106                 }
1107             }
1108         }
1109     }
1110     else
1111     {
1112         if (d5)
1113         {
1114             if (d3)
1115             {
1116                 if (d1)
1117                 {
1118             /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
1119                     z2 = d5 + d3;
1120                     z4 = d5 + d1;
1121                     z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
1122
1123                     tmp1 = MULTIPLY(d5, FIX(2.053119869));
1124                     tmp2 = MULTIPLY(d3, FIX(3.072711026));
1125                     tmp3 = MULTIPLY(d1, FIX(1.501321110));
1126                     z1 = MULTIPLY(d1, - FIX(0.899976223));
1127                     z2 = MULTIPLY(z2, - FIX(2.562915447));
1128                     z3 = MULTIPLY(d3, - FIX(1.961570560));
1129                     z4 = MULTIPLY(z4, - FIX(0.390180644));
1130
1131                     z3 += z5;
1132                     z4 += z5;
1133
1134                     tmp0 = z1 + z3;
1135                     tmp1 += z2 + z4;
1136                     tmp2 += z2 + z3;
1137                     tmp3 += z1 + z4;
1138                 }
1139                 else
1140                 {
1141             /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
1142                     z2 = d5 + d3;
1143                     z5 = MULTIPLY(z2, FIX(1.175875602));
1144
1145                     tmp1 = MULTIPLY(d5, FIX2(1.662939225));
1146                     tmp2 = MULTIPLY(d3, FIX2(1.111140466));
1147                     z2 = MULTIPLY(z2, - FIX2(1.387039845));
1148                     z3 = MULTIPLY(d3, - FIX(1.961570560));
1149                     z4 = MULTIPLY(d5, - FIX(0.390180644));
1150
1151                     tmp0 = z3 + z5;
1152                     tmp1 += z2;
1153                     tmp2 += z2;
1154                     tmp3 = z4 + z5;
1155                 }
1156             }
1157             else
1158             {
1159                 if (d1)
1160                 {
1161             /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
1162                     z4 = d5 + d1;
1163                     z5 = MULTIPLY(z4, FIX(1.175875602));
1164
1165                     tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1166                     tmp3 = MULTIPLY(d1, FIX2(0.601344887));
1167                     z1 = MULTIPLY(d1, - FIX(0.899976223));
1168                     z2 = MULTIPLY(d5, - FIX(2.562915447));
1169                     z4 = MULTIPLY(z4, FIX2(0.785694958));
1170
1171                     tmp0 = z1 + z5;
1172                     tmp1 += z4;
1173                     tmp2 = z2 + z5;
1174                     tmp3 += z4;
1175                 }
1176                 else
1177                 {
1178             /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
1179                     tmp0 = MULTIPLY(d5, FIX(1.175875602));
1180                     tmp1 = MULTIPLY(d5, FIX2(0.275899380));
1181                     tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
1182                     tmp3 = MULTIPLY(d5, FIX2(0.785694958));
1183                 }
1184             }
1185         }
1186         else
1187         {
1188             if (d3)
1189             {
1190                 if (d1)
1191                 {
1192             /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
1193                     z5 = d3 + d1;
1194
1195                     tmp2 = MULTIPLY(d3, - FIX(1.451774981));
1196                     tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
1197                     z1 = MULTIPLY(d1, FIX(1.061594337));
1198                     z2 = MULTIPLY(d3, - FIX(2.172734803));
1199                     z4 = MULTIPLY(z5, FIX(0.785694958));
1200                     z5 = MULTIPLY(z5, FIX(1.175875602));
1201
1202                     tmp0 = z1 - z4;
1203                     tmp1 = z2 + z4;
1204                     tmp2 += z5;
1205                     tmp3 += z5;
1206                 }
1207                 else
1208                 {
1209             /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
1210                     tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
1211                     tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
1212                     tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
1213                     tmp3 = MULTIPLY(d3, FIX(1.175875602));
1214                 }
1215             }
1216             else
1217             {
1218                 if (d1)
1219                 {
1220             /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
1221                     tmp0 = MULTIPLY(d1, FIX2(0.275899379));
1222                     tmp1 = MULTIPLY(d1, FIX2(0.785694958));
1223                     tmp2 = MULTIPLY(d1, FIX(1.175875602));
1224                     tmp3 = MULTIPLY(d1, FIX2(1.387039845));
1225                 }
1226                 else
1227                 {
1228             /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
1229                     tmp0 = tmp1 = tmp2 = tmp3 = 0;
1230                 }
1231             }
1232         }
1233     }
1234
1235     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1236
1237     dataptr[DCTSIZE*0] = (dctelem_t) DESCALE(tmp10 + tmp3,
1238                        CONST_BITS+PASS1_BITS+3);
1239     dataptr[DCTSIZE*7] = (dctelem_t) DESCALE(tmp10 - tmp3,
1240                        CONST_BITS+PASS1_BITS+3);
1241     dataptr[DCTSIZE*1] = (dctelem_t) DESCALE(tmp11 + tmp2,
1242                        CONST_BITS+PASS1_BITS+3);
1243     dataptr[DCTSIZE*6] = (dctelem_t) DESCALE(tmp11 - tmp2,
1244                        CONST_BITS+PASS1_BITS+3);
1245     dataptr[DCTSIZE*2] = (dctelem_t) DESCALE(tmp12 + tmp1,
1246                        CONST_BITS+PASS1_BITS+3);
1247     dataptr[DCTSIZE*5] = (dctelem_t) DESCALE(tmp12 - tmp1,
1248                        CONST_BITS+PASS1_BITS+3);
1249     dataptr[DCTSIZE*3] = (dctelem_t) DESCALE(tmp13 + tmp0,
1250                        CONST_BITS+PASS1_BITS+3);
1251     dataptr[DCTSIZE*4] = (dctelem_t) DESCALE(tmp13 - tmp0,
1252                        CONST_BITS+PASS1_BITS+3);
1253
1254     dataptr++;             /* advance pointer to next column */
1255     }
1256 }
1257
1258 #include "idct_sparse.h"
1259 #include "idct_decl.h"