Final 350 project
Dependencies: uzair Camera_LS_Y201 F7_Ethernet LCD_DISCO_F746NG NetworkAPI SDFileSystem mbed
jfdctflt.c
00001 /* 00002 * jfdctflt.c 00003 * 00004 * Copyright (C) 1994-1996, Thomas G. Lane. 00005 * Modified 2003-2015 by Guido Vollbeding. 00006 * This file is part of the Independent JPEG Group's software. 00007 * For conditions of distribution and use, see the accompanying README file. 00008 * 00009 * This file contains a floating-point implementation of the 00010 * forward DCT (Discrete Cosine Transform). 00011 * 00012 * This implementation should be more accurate than either of the integer 00013 * DCT implementations. However, it may not give the same results on all 00014 * machines because of differences in roundoff behavior. Speed will depend 00015 * on the hardware's floating point capacity. 00016 * 00017 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT 00018 * on each column. Direct algorithms are also available, but they are 00019 * much more complex and seem not to be any faster when reduced to code. 00020 * 00021 * This implementation is based on Arai, Agui, and Nakajima's algorithm for 00022 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in 00023 * Japanese, but the algorithm is described in the Pennebaker & Mitchell 00024 * JPEG textbook (see REFERENCES section in file README). The following code 00025 * is based directly on figure 4-8 in P&M. 00026 * While an 8-point DCT cannot be done in less than 11 multiplies, it is 00027 * possible to arrange the computation so that many of the multiplies are 00028 * simple scalings of the final outputs. These multiplies can then be 00029 * folded into the multiplications or divisions by the JPEG quantization 00030 * table entries. The AA&N method leaves only 5 multiplies and 29 adds 00031 * to be done in the DCT itself. 00032 * The primary disadvantage of this method is that with a fixed-point 00033 * implementation, accuracy is lost due to imprecise representation of the 00034 * scaled quantization values. However, that problem does not arise if 00035 * we use floating point arithmetic. 00036 */ 00037 00038 #define JPEG_INTERNALS 00039 #include "jinclude.h" 00040 #include "jpeglib.h" 00041 #include "jdct.h" /* Private declarations for DCT subsystem */ 00042 00043 #ifdef DCT_FLOAT_SUPPORTED 00044 00045 00046 /* 00047 * This module is specialized to the case DCTSIZE = 8. 00048 */ 00049 00050 #if DCTSIZE != 8 00051 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ 00052 #endif 00053 00054 00055 /* 00056 * Perform the forward DCT on one block of samples. 00057 * 00058 * cK represents cos(K*pi/16). 00059 */ 00060 00061 GLOBAL(void) 00062 jpeg_fdct_float (FAST_FLOAT * data, JSAMPARRAY sample_data, JDIMENSION start_col) 00063 { 00064 FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; 00065 FAST_FLOAT tmp10, tmp11, tmp12, tmp13; 00066 FAST_FLOAT z1, z2, z3, z4, z5, z11, z13; 00067 FAST_FLOAT *dataptr; 00068 JSAMPROW elemptr; 00069 int ctr; 00070 00071 /* Pass 1: process rows. */ 00072 00073 dataptr = data; 00074 for (ctr = 0; ctr < DCTSIZE; ctr++) { 00075 elemptr = sample_data[ctr] + start_col; 00076 00077 /* Load data into workspace */ 00078 tmp0 = (FAST_FLOAT) (GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7])); 00079 tmp7 = (FAST_FLOAT) (GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7])); 00080 tmp1 = (FAST_FLOAT) (GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6])); 00081 tmp6 = (FAST_FLOAT) (GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6])); 00082 tmp2 = (FAST_FLOAT) (GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5])); 00083 tmp5 = (FAST_FLOAT) (GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5])); 00084 tmp3 = (FAST_FLOAT) (GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4])); 00085 tmp4 = (FAST_FLOAT) (GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4])); 00086 00087 /* Even part */ 00088 00089 tmp10 = tmp0 + tmp3; /* phase 2 */ 00090 tmp13 = tmp0 - tmp3; 00091 tmp11 = tmp1 + tmp2; 00092 tmp12 = tmp1 - tmp2; 00093 00094 /* Apply unsigned->signed conversion. */ 00095 dataptr[0] = tmp10 + tmp11 - 8 * CENTERJSAMPLE; /* phase 3 */ 00096 dataptr[4] = tmp10 - tmp11; 00097 00098 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ 00099 dataptr[2] = tmp13 + z1; /* phase 5 */ 00100 dataptr[6] = tmp13 - z1; 00101 00102 /* Odd part */ 00103 00104 tmp10 = tmp4 + tmp5; /* phase 2 */ 00105 tmp11 = tmp5 + tmp6; 00106 tmp12 = tmp6 + tmp7; 00107 00108 /* The rotator is modified from fig 4-8 to avoid extra negations. */ 00109 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ 00110 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ 00111 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ 00112 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ 00113 00114 z11 = tmp7 + z3; /* phase 5 */ 00115 z13 = tmp7 - z3; 00116 00117 dataptr[5] = z13 + z2; /* phase 6 */ 00118 dataptr[3] = z13 - z2; 00119 dataptr[1] = z11 + z4; 00120 dataptr[7] = z11 - z4; 00121 00122 dataptr += DCTSIZE; /* advance pointer to next row */ 00123 } 00124 00125 /* Pass 2: process columns. */ 00126 00127 dataptr = data; 00128 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { 00129 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; 00130 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; 00131 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; 00132 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; 00133 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; 00134 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; 00135 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; 00136 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; 00137 00138 /* Even part */ 00139 00140 tmp10 = tmp0 + tmp3; /* phase 2 */ 00141 tmp13 = tmp0 - tmp3; 00142 tmp11 = tmp1 + tmp2; 00143 tmp12 = tmp1 - tmp2; 00144 00145 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ 00146 dataptr[DCTSIZE*4] = tmp10 - tmp11; 00147 00148 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ 00149 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ 00150 dataptr[DCTSIZE*6] = tmp13 - z1; 00151 00152 /* Odd part */ 00153 00154 tmp10 = tmp4 + tmp5; /* phase 2 */ 00155 tmp11 = tmp5 + tmp6; 00156 tmp12 = tmp6 + tmp7; 00157 00158 /* The rotator is modified from fig 4-8 to avoid extra negations. */ 00159 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ 00160 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ 00161 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ 00162 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ 00163 00164 z11 = tmp7 + z3; /* phase 5 */ 00165 z13 = tmp7 - z3; 00166 00167 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ 00168 dataptr[DCTSIZE*3] = z13 - z2; 00169 dataptr[DCTSIZE*1] = z11 + z4; 00170 dataptr[DCTSIZE*7] = z11 - z4; 00171 00172 dataptr++; /* advance pointer to next column */ 00173 } 00174 } 00175 00176 #endif /* DCT_FLOAT_SUPPORTED */
Generated on Wed Jul 13 2022 18:56:09 by 1.7.2