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

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