1/* 2 * jfdctfst.c 3 * 4 * This file is part of the Independent JPEG Group's software. 5 * 6 * The authors make NO WARRANTY or representation, either express or implied, 7 * with respect to this software, its quality, accuracy, merchantability, or 8 * fitness for a particular purpose. This software is provided "AS IS", and 9 * you, its user, assume the entire risk as to its quality and accuracy. 10 * 11 * This software is copyright (C) 1994-1996, Thomas G. Lane. 12 * All Rights Reserved except as specified below. 13 * 14 * Permission is hereby granted to use, copy, modify, and distribute this 15 * software (or portions thereof) for any purpose, without fee, subject to 16 * these conditions: 17 * (1) If any part of the source code for this software is distributed, then 18 * this README file must be included, with this copyright and no-warranty 19 * notice unaltered; and any additions, deletions, or changes to the original 20 * files must be clearly indicated in accompanying documentation. 21 * (2) If only executable code is distributed, then the accompanying 22 * documentation must state that "this software is based in part on the work 23 * of the Independent JPEG Group". 24 * (3) Permission for use of this software is granted only if the user accepts 25 * full responsibility for any undesirable consequences; the authors accept 26 * NO LIABILITY for damages of any kind. 27 * 28 * These conditions apply to any software derived from or based on the IJG 29 * code, not just to the unmodified library. If you use our work, you ought 30 * to acknowledge us. 31 * 32 * Permission is NOT granted for the use of any IJG author's name or company 33 * name in advertising or publicity relating to this software or products 34 * derived from it. This software may be referred to only as "the Independent 35 * JPEG Group's software". 36 * 37 * We specifically permit and encourage the use of this software as the basis 38 * of commercial products, provided that all warranty or liability claims are 39 * assumed by the product vendor. 40 * 41 * This file contains a fast, not so accurate integer implementation of the 42 * forward DCT (Discrete Cosine Transform). 43 * 44 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT 45 * on each column. Direct algorithms are also available, but they are 46 * much more complex and seem not to be any faster when reduced to code. 47 * 48 * This implementation is based on Arai, Agui, and Nakajima's algorithm for 49 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in 50 * Japanese, but the algorithm is described in the Pennebaker & Mitchell 51 * JPEG textbook (see REFERENCES section in file README). The following code 52 * is based directly on figure 4-8 in P&M. 53 * While an 8-point DCT cannot be done in less than 11 multiplies, it is 54 * possible to arrange the computation so that many of the multiplies are 55 * simple scalings of the final outputs. These multiplies can then be 56 * folded into the multiplications or divisions by the JPEG quantization 57 * table entries. The AA&N method leaves only 5 multiplies and 29 adds 58 * to be done in the DCT itself. 59 * The primary disadvantage of this method is that with fixed-point math, 60 * accuracy is lost due to imprecise representation of the scaled 61 * quantization values. The smaller the quantization table entry, the less 62 * precise the scaled value, so this implementation does worse with high- 63 * quality-setting files than with low-quality ones. 64 */ 65 66/** 67 * @file 68 * Independent JPEG Group's fast AAN dct. 69 */ 70 71#include <stdlib.h> 72#include <stdio.h> 73#include "libavutil/common.h" 74#include "dsputil.h" 75 76#define DCTSIZE 8 77#define GLOBAL(x) x 78#define RIGHT_SHIFT(x, n) ((x) >> (n)) 79 80/* 81 * This module is specialized to the case DCTSIZE = 8. 82 */ 83 84#if DCTSIZE != 8 85 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ 86#endif 87 88 89/* Scaling decisions are generally the same as in the LL&M algorithm; 90 * see jfdctint.c for more details. However, we choose to descale 91 * (right shift) multiplication products as soon as they are formed, 92 * rather than carrying additional fractional bits into subsequent additions. 93 * This compromises accuracy slightly, but it lets us save a few shifts. 94 * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) 95 * everywhere except in the multiplications proper; this saves a good deal 96 * of work on 16-bit-int machines. 97 * 98 * Again to save a few shifts, the intermediate results between pass 1 and 99 * pass 2 are not upscaled, but are represented only to integral precision. 100 * 101 * A final compromise is to represent the multiplicative constants to only 102 * 8 fractional bits, rather than 13. This saves some shifting work on some 103 * machines, and may also reduce the cost of multiplication (since there 104 * are fewer one-bits in the constants). 105 */ 106 107#define CONST_BITS 8 108 109 110/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus 111 * causing a lot of useless floating-point operations at run time. 112 * To get around this we use the following pre-calculated constants. 113 * If you change CONST_BITS you may want to add appropriate values. 114 * (With a reasonable C compiler, you can just rely on the FIX() macro...) 115 */ 116 117#if CONST_BITS == 8 118#define FIX_0_382683433 ((int32_t) 98) /* FIX(0.382683433) */ 119#define FIX_0_541196100 ((int32_t) 139) /* FIX(0.541196100) */ 120#define FIX_0_707106781 ((int32_t) 181) /* FIX(0.707106781) */ 121#define FIX_1_306562965 ((int32_t) 334) /* FIX(1.306562965) */ 122#else 123#define FIX_0_382683433 FIX(0.382683433) 124#define FIX_0_541196100 FIX(0.541196100) 125#define FIX_0_707106781 FIX(0.707106781) 126#define FIX_1_306562965 FIX(1.306562965) 127#endif 128 129 130/* We can gain a little more speed, with a further compromise in accuracy, 131 * by omitting the addition in a descaling shift. This yields an incorrectly 132 * rounded result half the time... 133 */ 134 135#ifndef USE_ACCURATE_ROUNDING 136#undef DESCALE 137#define DESCALE(x,n) RIGHT_SHIFT(x, n) 138#endif 139 140 141/* Multiply a DCTELEM variable by an int32_t constant, and immediately 142 * descale to yield a DCTELEM result. 143 */ 144 145#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) 146 147static av_always_inline void row_fdct(DCTELEM * data){ 148 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; 149 int_fast16_t tmp10, tmp11, tmp12, tmp13; 150 int_fast16_t z1, z2, z3, z4, z5, z11, z13; 151 DCTELEM *dataptr; 152 int ctr; 153 154 /* Pass 1: process rows. */ 155 156 dataptr = data; 157 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { 158 tmp0 = dataptr[0] + dataptr[7]; 159 tmp7 = dataptr[0] - dataptr[7]; 160 tmp1 = dataptr[1] + dataptr[6]; 161 tmp6 = dataptr[1] - dataptr[6]; 162 tmp2 = dataptr[2] + dataptr[5]; 163 tmp5 = dataptr[2] - dataptr[5]; 164 tmp3 = dataptr[3] + dataptr[4]; 165 tmp4 = dataptr[3] - dataptr[4]; 166 167 /* Even part */ 168 169 tmp10 = tmp0 + tmp3; /* phase 2 */ 170 tmp13 = tmp0 - tmp3; 171 tmp11 = tmp1 + tmp2; 172 tmp12 = tmp1 - tmp2; 173 174 dataptr[0] = tmp10 + tmp11; /* phase 3 */ 175 dataptr[4] = tmp10 - tmp11; 176 177 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ 178 dataptr[2] = tmp13 + z1; /* phase 5 */ 179 dataptr[6] = tmp13 - z1; 180 181 /* Odd part */ 182 183 tmp10 = tmp4 + tmp5; /* phase 2 */ 184 tmp11 = tmp5 + tmp6; 185 tmp12 = tmp6 + tmp7; 186 187 /* The rotator is modified from fig 4-8 to avoid extra negations. */ 188 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ 189 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ 190 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ 191 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ 192 193 z11 = tmp7 + z3; /* phase 5 */ 194 z13 = tmp7 - z3; 195 196 dataptr[5] = z13 + z2; /* phase 6 */ 197 dataptr[3] = z13 - z2; 198 dataptr[1] = z11 + z4; 199 dataptr[7] = z11 - z4; 200 201 dataptr += DCTSIZE; /* advance pointer to next row */ 202 } 203} 204 205/* 206 * Perform the forward DCT on one block of samples. 207 */ 208 209GLOBAL(void) 210fdct_ifast (DCTELEM * data) 211{ 212 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; 213 int_fast16_t tmp10, tmp11, tmp12, tmp13; 214 int_fast16_t z1, z2, z3, z4, z5, z11, z13; 215 DCTELEM *dataptr; 216 int ctr; 217 218 row_fdct(data); 219 220 /* Pass 2: process columns. */ 221 222 dataptr = data; 223 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { 224 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; 225 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; 226 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; 227 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; 228 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; 229 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; 230 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; 231 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; 232 233 /* Even part */ 234 235 tmp10 = tmp0 + tmp3; /* phase 2 */ 236 tmp13 = tmp0 - tmp3; 237 tmp11 = tmp1 + tmp2; 238 tmp12 = tmp1 - tmp2; 239 240 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ 241 dataptr[DCTSIZE*4] = tmp10 - tmp11; 242 243 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ 244 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ 245 dataptr[DCTSIZE*6] = tmp13 - z1; 246 247 /* Odd part */ 248 249 tmp10 = tmp4 + tmp5; /* phase 2 */ 250 tmp11 = tmp5 + tmp6; 251 tmp12 = tmp6 + tmp7; 252 253 /* The rotator is modified from fig 4-8 to avoid extra negations. */ 254 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ 255 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ 256 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ 257 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ 258 259 z11 = tmp7 + z3; /* phase 5 */ 260 z13 = tmp7 - z3; 261 262 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ 263 dataptr[DCTSIZE*3] = z13 - z2; 264 dataptr[DCTSIZE*1] = z11 + z4; 265 dataptr[DCTSIZE*7] = z11 - z4; 266 267 dataptr++; /* advance pointer to next column */ 268 } 269} 270 271/* 272 * Perform the forward 2-4-8 DCT on one block of samples. 273 */ 274 275GLOBAL(void) 276fdct_ifast248 (DCTELEM * data) 277{ 278 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; 279 int_fast16_t tmp10, tmp11, tmp12, tmp13; 280 int_fast16_t z1; 281 DCTELEM *dataptr; 282 int ctr; 283 284 row_fdct(data); 285 286 /* Pass 2: process columns. */ 287 288 dataptr = data; 289 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { 290 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*1]; 291 tmp1 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3]; 292 tmp2 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5]; 293 tmp3 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7]; 294 tmp4 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*1]; 295 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3]; 296 tmp6 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5]; 297 tmp7 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7]; 298 299 /* Even part */ 300 301 tmp10 = tmp0 + tmp3; 302 tmp11 = tmp1 + tmp2; 303 tmp12 = tmp1 - tmp2; 304 tmp13 = tmp0 - tmp3; 305 306 dataptr[DCTSIZE*0] = tmp10 + tmp11; 307 dataptr[DCTSIZE*4] = tmp10 - tmp11; 308 309 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); 310 dataptr[DCTSIZE*2] = tmp13 + z1; 311 dataptr[DCTSIZE*6] = tmp13 - z1; 312 313 tmp10 = tmp4 + tmp7; 314 tmp11 = tmp5 + tmp6; 315 tmp12 = tmp5 - tmp6; 316 tmp13 = tmp4 - tmp7; 317 318 dataptr[DCTSIZE*1] = tmp10 + tmp11; 319 dataptr[DCTSIZE*5] = tmp10 - tmp11; 320 321 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); 322 dataptr[DCTSIZE*3] = tmp13 + z1; 323 dataptr[DCTSIZE*7] = tmp13 - z1; 324 325 dataptr++; /* advance pointer to next column */ 326 } 327} 328 329 330#undef GLOBAL 331#undef CONST_BITS 332#undef DESCALE 333#undef FIX_0_541196100 334#undef FIX_1_306562965 335