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