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