--- fdct.c 2002/03/08 02:44:39 1.1 +++ fdct.c 2002/11/16 23:51:58 1.4 @@ -1,29 +1,59 @@ -/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */ - -/* - * Disclaimer of Warranty +/***************************************************************************** * - * These software programs are available to the user without any license fee or - * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims - * any and all warranties, whether express, implied, or statuary, including any - * implied warranties or merchantability or of fitness for a particular - * purpose. In no event shall the copyright-holder be liable for any - * incidental, punitive, or consequential damages of any kind whatsoever - * arising from the use of these programs. - * - * This disclaimer of warranty extends to the user of these programs and user's - * customers, employees, agents, transferees, successors, and assigns. - * - * The MPEG Software Simulation Group does not represent or warrant that the - * programs furnished hereunder are free of infringement of any third-party - * patents. - * - * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware, - * are subject to royalty fees to patent holders. Many of these patents are - * general enough such that they are unavoidable regardless of implementation - * design. + * XVID MPEG-4 VIDEO CODEC + * - fast disrete cosine transformation - integer C version * - */ + * These routines are from Independent JPEG Group's free JPEG software + * Copyright (C) 1991-1998, Thomas G. Lane (see the file README.IJG) + * + * This file is part of XviD, a free MPEG-4 video encoder/decoder + * + * XviD is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Under section 8 of the GNU General Public License, the copyright + * holders of XVID explicitly forbid distribution in the following + * countries: + * + * - Japan + * - United States of America + * + * Linking XviD statically or dynamically with other modules is making a + * combined work based on XviD. Thus, the terms and conditions of the + * GNU General Public License cover the whole combination. + * + * As a special exception, the copyright holders of XviD give you + * permission to link XviD with independent modules that communicate with + * XviD solely through the VFW1.1 and DShow interfaces, regardless of the + * license terms of these independent modules, and to copy and distribute + * the resulting combined work under terms of your choice, provided that + * every copy of the combined work is accompanied by a complete copy of + * the source code of XviD (the version of XviD used to produce the + * combined work), being distributed under the terms of the GNU General + * Public License plus this exception. An independent module is a module + * which is not derived from or based on XviD. + * + * Note that people who make modified versions of XviD are not obligated + * to grant this special exception for their modified versions; it is + * their choice whether to do so. The GNU General Public License gives + * permission to release a modified version without this exception; this + * exception also makes it possible to release a modified version which + * carries forward this exception. + * + * $Id: fdct.c,v 1.4 2002/11/16 23:51:58 edgomez Exp $ + * + *************************************************************************/ /* This routine is a slow-but-accurate integer implementation of the * forward DCT (Discrete Cosine Transform). Taken from the IJG software @@ -115,146 +145,148 @@ * Perform an integer forward DCT on one block of samples. */ -void fdct_int32(short * const block) +void +fdct_int32(short *const block) { - int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; - int tmp10, tmp11, tmp12, tmp13; - int z1, z2, z3, z4, z5; - short *blkptr; - int *dataptr; - int data[64]; - int i; - - /* Pass 1: process rows. */ - /* Note results are scaled up by sqrt(8) compared to a true DCT; */ - /* furthermore, we scale the results by 2**PASS1_BITS. */ - - dataptr = data; - blkptr = block; - for (i = 0; i < 8; i++) - { - tmp0 = blkptr[0] + blkptr[7]; - tmp7 = blkptr[0] - blkptr[7]; - tmp1 = blkptr[1] + blkptr[6]; - tmp6 = blkptr[1] - blkptr[6]; - tmp2 = blkptr[2] + blkptr[5]; - tmp5 = blkptr[2] - blkptr[5]; - tmp3 = blkptr[3] + blkptr[4]; - tmp4 = blkptr[3] - blkptr[4]; - - /* Even part per LL&M figure 1 --- note that published figure is faulty; - * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". - */ - - tmp10 = tmp0 + tmp3; - tmp13 = tmp0 - tmp3; - tmp11 = tmp1 + tmp2; - tmp12 = tmp1 - tmp2; - - dataptr[0] = (tmp10 + tmp11) << PASS1_BITS; - dataptr[4] = (tmp10 - tmp11) << PASS1_BITS; - - z1 = (tmp12 + tmp13) * FIX_0_541196100; - dataptr[2] = DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS - PASS1_BITS); - dataptr[6] = DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS - PASS1_BITS); - - /* Odd part per figure 8 --- note paper omits factor of sqrt(2). - * cK represents cos(K*pi/16). - * i0..i3 in the paper are tmp4..tmp7 here. - */ - - z1 = tmp4 + tmp7; - z2 = tmp5 + tmp6; - z3 = tmp4 + tmp6; - z4 = tmp5 + tmp7; - z5 = (z3 + z4) * FIX_1_175875602; /* sqrt(2) * c3 */ - - tmp4 *= FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */ - tmp5 *= FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */ - tmp6 *= FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */ - tmp7 *= FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */ - z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */ - z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */ - z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */ - z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */ - - z3 += z5; - z4 += z5; - - dataptr[7] = DESCALE(tmp4 + z1 + z3, CONST_BITS - PASS1_BITS); - dataptr[5] = DESCALE(tmp5 + z2 + z4, CONST_BITS - PASS1_BITS); - dataptr[3] = DESCALE(tmp6 + z2 + z3, CONST_BITS - PASS1_BITS); - dataptr[1] = DESCALE(tmp7 + z1 + z4, CONST_BITS - PASS1_BITS); - - dataptr += 8; /* advance pointer to next row */ - blkptr += 8; - } - - /* Pass 2: process columns. - * We remove the PASS1_BITS scaling, but leave the results scaled up - * by an overall factor of 8. - */ - - dataptr = data; - for (i = 0; i < 8; i++) - { - tmp0 = dataptr[0] + dataptr[56]; - tmp7 = dataptr[0] - dataptr[56]; - tmp1 = dataptr[8] + dataptr[48]; - tmp6 = dataptr[8] - dataptr[48]; - tmp2 = dataptr[16] + dataptr[40]; - tmp5 = dataptr[16] - dataptr[40]; - tmp3 = dataptr[24] + dataptr[32]; - tmp4 = dataptr[24] - dataptr[32]; - - /* Even part per LL&M figure 1 --- note that published figure is faulty; - * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". - */ - - tmp10 = tmp0 + tmp3; - tmp13 = tmp0 - tmp3; - tmp11 = tmp1 + tmp2; - tmp12 = tmp1 - tmp2; - - dataptr[0] = DESCALE(tmp10 + tmp11, PASS1_BITS); - dataptr[32] = DESCALE(tmp10 - tmp11, PASS1_BITS); - - z1 = (tmp12 + tmp13) * FIX_0_541196100; - dataptr[16] = DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS + PASS1_BITS); - dataptr[48] = DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS + PASS1_BITS); - - /* Odd part per figure 8 --- note paper omits factor of sqrt(2). - * cK represents cos(K*pi/16). - * i0..i3 in the paper are tmp4..tmp7 here. - */ - - z1 = tmp4 + tmp7; - z2 = tmp5 + tmp6; - z3 = tmp4 + tmp6; - z4 = tmp5 + tmp7; - z5 = (z3 + z4) * FIX_1_175875602; /* sqrt(2) * c3 */ - - tmp4 *= FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */ - tmp5 *= FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */ - tmp6 *= FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */ - tmp7 *= FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */ - z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */ - z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */ - z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */ - z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */ - - z3 += z5; - z4 += z5; - - dataptr[56] = DESCALE(tmp4 + z1 + z3, CONST_BITS + PASS1_BITS); - dataptr[40] = DESCALE(tmp5 + z2 + z4, CONST_BITS + PASS1_BITS); - dataptr[24] = DESCALE(tmp6 + z2 + z3, CONST_BITS + PASS1_BITS); - dataptr[8] = DESCALE(tmp7 + z1 + z4, CONST_BITS + PASS1_BITS); - - dataptr++; /* advance pointer to next column */ - } - /* descale */ - for (i = 0; i < 64; i++) - block[i] = (short int) DESCALE(data[i], 3); + int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + int tmp10, tmp11, tmp12, tmp13; + int z1, z2, z3, z4, z5; + short *blkptr; + int *dataptr; + int data[64]; + int i; + + /* Pass 1: process rows. */ + /* Note results are scaled up by sqrt(8) compared to a true DCT; */ + /* furthermore, we scale the results by 2**PASS1_BITS. */ + + dataptr = data; + blkptr = block; + for (i = 0; i < 8; i++) { + tmp0 = blkptr[0] + blkptr[7]; + tmp7 = blkptr[0] - blkptr[7]; + tmp1 = blkptr[1] + blkptr[6]; + tmp6 = blkptr[1] - blkptr[6]; + tmp2 = blkptr[2] + blkptr[5]; + tmp5 = blkptr[2] - blkptr[5]; + tmp3 = blkptr[3] + blkptr[4]; + tmp4 = blkptr[3] - blkptr[4]; + + /* Even part per LL&M figure 1 --- note that published figure is faulty; + * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". + */ + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[0] = (tmp10 + tmp11) << PASS1_BITS; + dataptr[4] = (tmp10 - tmp11) << PASS1_BITS; + + z1 = (tmp12 + tmp13) * FIX_0_541196100; + dataptr[2] = + DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS - PASS1_BITS); + dataptr[6] = + DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS - PASS1_BITS); + + /* Odd part per figure 8 --- note paper omits factor of sqrt(2). + * cK represents cos(K*pi/16). + * i0..i3 in the paper are tmp4..tmp7 here. + */ + + z1 = tmp4 + tmp7; + z2 = tmp5 + tmp6; + z3 = tmp4 + tmp6; + z4 = tmp5 + tmp7; + z5 = (z3 + z4) * FIX_1_175875602; /* sqrt(2) * c3 */ + + tmp4 *= FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp5 *= FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp6 *= FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp7 *= FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */ + z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */ + z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */ + z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + dataptr[7] = DESCALE(tmp4 + z1 + z3, CONST_BITS - PASS1_BITS); + dataptr[5] = DESCALE(tmp5 + z2 + z4, CONST_BITS - PASS1_BITS); + dataptr[3] = DESCALE(tmp6 + z2 + z3, CONST_BITS - PASS1_BITS); + dataptr[1] = DESCALE(tmp7 + z1 + z4, CONST_BITS - PASS1_BITS); + + dataptr += 8; /* advance pointer to next row */ + blkptr += 8; + } + + /* Pass 2: process columns. + * We remove the PASS1_BITS scaling, but leave the results scaled up + * by an overall factor of 8. + */ + + dataptr = data; + for (i = 0; i < 8; i++) { + tmp0 = dataptr[0] + dataptr[56]; + tmp7 = dataptr[0] - dataptr[56]; + tmp1 = dataptr[8] + dataptr[48]; + tmp6 = dataptr[8] - dataptr[48]; + tmp2 = dataptr[16] + dataptr[40]; + tmp5 = dataptr[16] - dataptr[40]; + tmp3 = dataptr[24] + dataptr[32]; + tmp4 = dataptr[24] - dataptr[32]; + + /* Even part per LL&M figure 1 --- note that published figure is faulty; + * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". + */ + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[0] = DESCALE(tmp10 + tmp11, PASS1_BITS); + dataptr[32] = DESCALE(tmp10 - tmp11, PASS1_BITS); + + z1 = (tmp12 + tmp13) * FIX_0_541196100; + dataptr[16] = + DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS + PASS1_BITS); + dataptr[48] = + DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS + PASS1_BITS); + + /* Odd part per figure 8 --- note paper omits factor of sqrt(2). + * cK represents cos(K*pi/16). + * i0..i3 in the paper are tmp4..tmp7 here. + */ + + z1 = tmp4 + tmp7; + z2 = tmp5 + tmp6; + z3 = tmp4 + tmp6; + z4 = tmp5 + tmp7; + z5 = (z3 + z4) * FIX_1_175875602; /* sqrt(2) * c3 */ + + tmp4 *= FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp5 *= FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp6 *= FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp7 *= FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */ + z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */ + z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */ + z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + dataptr[56] = DESCALE(tmp4 + z1 + z3, CONST_BITS + PASS1_BITS); + dataptr[40] = DESCALE(tmp5 + z2 + z4, CONST_BITS + PASS1_BITS); + dataptr[24] = DESCALE(tmp6 + z2 + z3, CONST_BITS + PASS1_BITS); + dataptr[8] = DESCALE(tmp7 + z1 + z4, CONST_BITS + PASS1_BITS); + + dataptr++; /* advance pointer to next column */ + } + /* descale */ + for (i = 0; i < 64; i++) + block[i] = (short int) DESCALE(data[i], 3); } -