1994-09-24 04:00:00 +04:00
|
|
|
/*
|
|
|
|
|
* jfdctfst.c
|
|
|
|
|
*
|
Replace INT32 with a new internal datatype (JLONG)
These days, INT32 is a commonly-defined datatype in system headers. We
cannot eliminate the definition of that datatype from jmorecfg.h, since
the INT32 typedef has technically been part of the libjpeg API since
version 5 (1994.) However, using INT32 internally is risky, because the
inclusion of a particular header (Xmd.h, for instance) could change the
definition of INT32 from long to int on 64-bit platforms and thus change
the internal behavior of libjpeg-turbo in unexpected ways (for instance,
failing to correctly set __INT32_IS_ACTUALLY_LONG to match the INT32
typedef-- perhaps as a result of including the wrong version of
jpeglib.h-- could cause libjpeg-turbo to produce incorrect results.)
The library has always been built in environments in which INT32 is
effectively long (on Windows, long is always 32-bit, so effectively it's
the same as int), so it makes sense to turn INT32 into an explicitly
long datatype. This ensures that libjpeg-turbo will always behave
consistently, regardless of the headers included at compile time.
Addresses a concern expressed in #26.
2015-10-15 01:32:39 +03:00
|
|
|
* This file was part of the Independent JPEG Group's software:
|
1996-02-07 03:00:00 +03:00
|
|
|
* Copyright (C) 1994-1996, Thomas G. Lane.
|
Replace INT32 with a new internal datatype (JLONG)
These days, INT32 is a commonly-defined datatype in system headers. We
cannot eliminate the definition of that datatype from jmorecfg.h, since
the INT32 typedef has technically been part of the libjpeg API since
version 5 (1994.) However, using INT32 internally is risky, because the
inclusion of a particular header (Xmd.h, for instance) could change the
definition of INT32 from long to int on 64-bit platforms and thus change
the internal behavior of libjpeg-turbo in unexpected ways (for instance,
failing to correctly set __INT32_IS_ACTUALLY_LONG to match the INT32
typedef-- perhaps as a result of including the wrong version of
jpeglib.h-- could cause libjpeg-turbo to produce incorrect results.)
The library has always been built in environments in which INT32 is
effectively long (on Windows, long is always 32-bit, so effectively it's
the same as int), so it makes sense to turn INT32 into an explicitly
long datatype. This ensures that libjpeg-turbo will always behave
consistently, regardless of the headers included at compile time.
Addresses a concern expressed in #26.
2015-10-15 01:32:39 +03:00
|
|
|
* libjpeg-turbo Modifications:
|
2016-05-24 18:23:56 +03:00
|
|
|
* Copyright (C) 2015, D. R. Commander.
|
2015-10-10 18:25:46 +03:00
|
|
|
* For conditions of distribution and use, see the accompanying README.ijg
|
|
|
|
|
* file.
|
1994-09-24 04:00:00 +04:00
|
|
|
*
|
|
|
|
|
* This file contains a fast, not so accurate integer implementation of the
|
|
|
|
|
* forward DCT (Discrete Cosine Transform).
|
|
|
|
|
*
|
|
|
|
|
* A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
|
|
|
|
|
* on each column. Direct algorithms are also available, but they are
|
|
|
|
|
* much more complex and seem not to be any faster when reduced to code.
|
|
|
|
|
*
|
|
|
|
|
* This implementation is based on Arai, Agui, and Nakajima's algorithm for
|
|
|
|
|
* scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
|
|
|
|
|
* Japanese, but the algorithm is described in the Pennebaker & Mitchell
|
2015-10-10 18:25:46 +03:00
|
|
|
* JPEG textbook (see REFERENCES section in file README.ijg). The following
|
|
|
|
|
* code is based directly on figure 4-8 in P&M.
|
1994-09-24 04:00:00 +04:00
|
|
|
* While an 8-point DCT cannot be done in less than 11 multiplies, it is
|
|
|
|
|
* possible to arrange the computation so that many of the multiplies are
|
|
|
|
|
* simple scalings of the final outputs. These multiplies can then be
|
|
|
|
|
* folded into the multiplications or divisions by the JPEG quantization
|
|
|
|
|
* table entries. The AA&N method leaves only 5 multiplies and 29 adds
|
|
|
|
|
* to be done in the DCT itself.
|
|
|
|
|
* The primary disadvantage of this method is that with fixed-point math,
|
|
|
|
|
* accuracy is lost due to imprecise representation of the scaled
|
|
|
|
|
* quantization values. The smaller the quantization table entry, the less
|
|
|
|
|
* precise the scaled value, so this implementation does worse with high-
|
|
|
|
|
* quality-setting files than with low-quality ones.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define JPEG_INTERNALS
|
|
|
|
|
#include "jinclude.h"
|
|
|
|
|
#include "jpeglib.h"
|
2014-05-09 22:00:32 +04:00
|
|
|
#include "jdct.h" /* Private declarations for DCT subsystem */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
#ifdef DCT_IFAST_SUPPORTED
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This module is specialized to the case DCTSIZE = 8.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if DCTSIZE != 8
|
|
|
|
|
Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Scaling decisions are generally the same as in the LL&M algorithm;
|
|
|
|
|
* see jfdctint.c for more details. However, we choose to descale
|
|
|
|
|
* (right shift) multiplication products as soon as they are formed,
|
|
|
|
|
* rather than carrying additional fractional bits into subsequent additions.
|
|
|
|
|
* This compromises accuracy slightly, but it lets us save a few shifts.
|
|
|
|
|
* More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
|
|
|
|
|
* everywhere except in the multiplications proper; this saves a good deal
|
|
|
|
|
* of work on 16-bit-int machines.
|
|
|
|
|
*
|
|
|
|
|
* Again to save a few shifts, the intermediate results between pass 1 and
|
|
|
|
|
* pass 2 are not upscaled, but are represented only to integral precision.
|
|
|
|
|
*
|
|
|
|
|
* A final compromise is to represent the multiplicative constants to only
|
|
|
|
|
* 8 fractional bits, rather than 13. This saves some shifting work on some
|
|
|
|
|
* machines, and may also reduce the cost of multiplication (since there
|
|
|
|
|
* are fewer one-bits in the constants).
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define CONST_BITS 8
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
|
|
|
|
|
* causing a lot of useless floating-point operations at run time.
|
|
|
|
|
* To get around this we use the following pre-calculated constants.
|
|
|
|
|
* If you change CONST_BITS you may want to add appropriate values.
|
|
|
|
|
* (With a reasonable C compiler, you can just rely on the FIX() macro...)
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if CONST_BITS == 8
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
#define FIX_0_382683433 ((JLONG)98) /* FIX(0.382683433) */
|
|
|
|
|
#define FIX_0_541196100 ((JLONG)139) /* FIX(0.541196100) */
|
|
|
|
|
#define FIX_0_707106781 ((JLONG)181) /* FIX(0.707106781) */
|
|
|
|
|
#define FIX_1_306562965 ((JLONG)334) /* FIX(1.306562965) */
|
1994-09-24 04:00:00 +04:00
|
|
|
#else
|
|
|
|
|
#define FIX_0_382683433 FIX(0.382683433)
|
|
|
|
|
#define FIX_0_541196100 FIX(0.541196100)
|
|
|
|
|
#define FIX_0_707106781 FIX(0.707106781)
|
|
|
|
|
#define FIX_1_306562965 FIX(1.306562965)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* We can gain a little more speed, with a further compromise in accuracy,
|
|
|
|
|
* by omitting the addition in a descaling shift. This yields an incorrectly
|
|
|
|
|
* rounded result half the time...
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef USE_ACCURATE_ROUNDING
|
|
|
|
|
#undef DESCALE
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
#define DESCALE(x, n) RIGHT_SHIFT(x, n)
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
Replace INT32 with a new internal datatype (JLONG)
These days, INT32 is a commonly-defined datatype in system headers. We
cannot eliminate the definition of that datatype from jmorecfg.h, since
the INT32 typedef has technically been part of the libjpeg API since
version 5 (1994.) However, using INT32 internally is risky, because the
inclusion of a particular header (Xmd.h, for instance) could change the
definition of INT32 from long to int on 64-bit platforms and thus change
the internal behavior of libjpeg-turbo in unexpected ways (for instance,
failing to correctly set __INT32_IS_ACTUALLY_LONG to match the INT32
typedef-- perhaps as a result of including the wrong version of
jpeglib.h-- could cause libjpeg-turbo to produce incorrect results.)
The library has always been built in environments in which INT32 is
effectively long (on Windows, long is always 32-bit, so effectively it's
the same as int), so it makes sense to turn INT32 into an explicitly
long datatype. This ensures that libjpeg-turbo will always behave
consistently, regardless of the headers included at compile time.
Addresses a concern expressed in #26.
2015-10-15 01:32:39 +03:00
|
|
|
/* Multiply a DCTELEM variable by an JLONG constant, and immediately
|
1994-09-24 04:00:00 +04:00
|
|
|
* descale to yield a DCTELEM result.
|
|
|
|
|
*/
|
|
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
#define MULTIPLY(var, const) ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Perform the forward DCT on one block of samples.
|
|
|
|
|
*/
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
GLOBAL(void)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
jpeg_fdct_ifast(DCTELEM *data)
|
1994-09-24 04:00:00 +04:00
|
|
|
{
|
|
|
|
|
DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
|
|
|
|
|
DCTELEM tmp10, tmp11, tmp12, tmp13;
|
|
|
|
|
DCTELEM z1, z2, z3, z4, z5, z11, z13;
|
|
|
|
|
DCTELEM *dataptr;
|
|
|
|
|
int ctr;
|
|
|
|
|
SHIFT_TEMPS
|
|
|
|
|
|
|
|
|
|
/* Pass 1: process rows. */
|
|
|
|
|
|
|
|
|
|
dataptr = data;
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
|
1994-09-24 04:00:00 +04:00
|
|
|
tmp0 = dataptr[0] + dataptr[7];
|
|
|
|
|
tmp7 = dataptr[0] - dataptr[7];
|
|
|
|
|
tmp1 = dataptr[1] + dataptr[6];
|
|
|
|
|
tmp6 = dataptr[1] - dataptr[6];
|
|
|
|
|
tmp2 = dataptr[2] + dataptr[5];
|
|
|
|
|
tmp5 = dataptr[2] - dataptr[5];
|
|
|
|
|
tmp3 = dataptr[3] + dataptr[4];
|
|
|
|
|
tmp4 = dataptr[3] - dataptr[4];
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Even part */
|
2014-05-09 22:00:32 +04:00
|
|
|
|
|
|
|
|
tmp10 = tmp0 + tmp3; /* phase 2 */
|
1994-09-24 04:00:00 +04:00
|
|
|
tmp13 = tmp0 - tmp3;
|
|
|
|
|
tmp11 = tmp1 + tmp2;
|
|
|
|
|
tmp12 = tmp1 - tmp2;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
dataptr[0] = tmp10 + tmp11; /* phase 3 */
|
|
|
|
|
dataptr[4] = tmp10 - tmp11;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
|
2014-05-09 22:00:32 +04:00
|
|
|
dataptr[2] = tmp13 + z1; /* phase 5 */
|
1994-09-24 04:00:00 +04:00
|
|
|
dataptr[6] = tmp13 - z1;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Odd part */
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
tmp10 = tmp4 + tmp5; /* phase 2 */
|
1994-09-24 04:00:00 +04:00
|
|
|
tmp11 = tmp5 + tmp6;
|
|
|
|
|
tmp12 = tmp6 + tmp7;
|
|
|
|
|
|
|
|
|
|
/* The rotator is modified from fig 4-8 to avoid extra negations. */
|
|
|
|
|
z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
|
|
|
|
|
z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
|
|
|
|
|
z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
|
|
|
|
|
z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
z11 = tmp7 + z3; /* phase 5 */
|
1994-09-24 04:00:00 +04:00
|
|
|
z13 = tmp7 - z3;
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
dataptr[5] = z13 + z2; /* phase 6 */
|
1994-09-24 04:00:00 +04:00
|
|
|
dataptr[3] = z13 - z2;
|
|
|
|
|
dataptr[1] = z11 + z4;
|
|
|
|
|
dataptr[7] = z11 - z4;
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
dataptr += DCTSIZE; /* advance pointer to next row */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Pass 2: process columns. */
|
|
|
|
|
|
|
|
|
|
dataptr = data;
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
|
|
|
|
|
tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
|
|
|
|
|
tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
|
|
|
|
|
tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
|
|
|
|
|
tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
|
|
|
|
|
tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
|
|
|
|
|
tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
|
|
|
|
|
tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
|
|
|
|
|
tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Even part */
|
2014-05-09 22:00:32 +04:00
|
|
|
|
|
|
|
|
tmp10 = tmp0 + tmp3; /* phase 2 */
|
1994-09-24 04:00:00 +04:00
|
|
|
tmp13 = tmp0 - tmp3;
|
|
|
|
|
tmp11 = tmp1 + tmp2;
|
|
|
|
|
tmp12 = tmp1 - tmp2;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
|
|
|
|
|
dataptr[DCTSIZE * 4] = tmp10 - tmp11;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
|
|
|
|
|
dataptr[DCTSIZE * 6] = tmp13 - z1;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Odd part */
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
tmp10 = tmp4 + tmp5; /* phase 2 */
|
1994-09-24 04:00:00 +04:00
|
|
|
tmp11 = tmp5 + tmp6;
|
|
|
|
|
tmp12 = tmp6 + tmp7;
|
|
|
|
|
|
|
|
|
|
/* The rotator is modified from fig 4-8 to avoid extra negations. */
|
|
|
|
|
z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
|
|
|
|
|
z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
|
|
|
|
|
z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
|
|
|
|
|
z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
z11 = tmp7 + z3; /* phase 5 */
|
1994-09-24 04:00:00 +04:00
|
|
|
z13 = tmp7 - z3;
|
|
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
|
|
|
|
|
dataptr[DCTSIZE * 3] = z13 - z2;
|
|
|
|
|
dataptr[DCTSIZE * 1] = z11 + z4;
|
|
|
|
|
dataptr[DCTSIZE * 7] = z11 - z4;
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
dataptr++; /* advance pointer to next column */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* DCT_IFAST_SUPPORTED */
|
