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

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