[svn] / trunk / xvidcore / src / quant / quant_mpeg4.c Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/src/quant/quant_mpeg4.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 723 - (view) (download)

1 : edgomez 442 /*****************************************************************************
2 : Isibaar 3 *
3 : edgomez 442 * XVID MPEG-4 VIDEO CODEC
4 :     * - Mpeg4 quantization/dequantization functions -
5 : Isibaar 3 *
6 : suxen_drol 499 * Copyright(C) 2002 Peter Ross <pross@xvid.org>
7 : Isibaar 3 *
8 : edgomez 653 * This file is part of XviD, a free MPEG-4 video encoder/decoder
9 : Isibaar 3 *
10 : edgomez 653 * XviD is free software; you can redistribute it and/or modify it
11 :     * under the terms of the GNU General Public License as published by
12 :     * the Free Software Foundation; either version 2 of the License, or
13 : edgomez 442 * (at your option) any later version.
14 : Isibaar 3 *
15 : edgomez 442 * This program is distributed in the hope that it will be useful,
16 : edgomez 653 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : edgomez 442 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 :     * GNU General Public License for more details.
19 : Isibaar 3 *
20 : edgomez 442 * You should have received a copy of the GNU General Public License
21 : edgomez 653 * along with this program; if not, write to the Free Software
22 : edgomez 442 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 : Isibaar 3 *
24 : edgomez 653 * Under section 8 of the GNU General Public License, the copyright
25 :     * holders of XVID explicitly forbid distribution in the following
26 :     * countries:
27 : Isibaar 3 *
28 : edgomez 653 * - Japan
29 :     * - United States of America
30 :     *
31 :     * Linking XviD statically or dynamically with other modules is making a
32 :     * combined work based on XviD. Thus, the terms and conditions of the
33 :     * GNU General Public License cover the whole combination.
34 :     *
35 :     * As a special exception, the copyright holders of XviD give you
36 :     * permission to link XviD with independent modules that communicate with
37 :     * XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38 :     * license terms of these independent modules, and to copy and distribute
39 :     * the resulting combined work under terms of your choice, provided that
40 :     * every copy of the combined work is accompanied by a complete copy of
41 :     * the source code of XviD (the version of XviD used to produce the
42 :     * combined work), being distributed under the terms of the GNU General
43 :     * Public License plus this exception. An independent module is a module
44 :     * which is not derived from or based on XviD.
45 :     *
46 :     * Note that people who make modified versions of XviD are not obligated
47 :     * to grant this special exception for their modified versions; it is
48 :     * their choice whether to do so. The GNU General Public License gives
49 :     * permission to release a modified version without this exception; this
50 :     * exception also makes it possible to release a modified version which
51 :     * carries forward this exception.
52 :     *
53 : edgomez 723 * $Id: quant_mpeg4.c,v 1.8 2002-12-15 01:21:12 edgomez Exp $
54 : edgomez 653 *
55 : edgomez 442 ****************************************************************************/
56 : Isibaar 3
57 :     #include "quant_mpeg4.h"
58 : Isibaar 4 #include "quant_matrix.h"
59 : Isibaar 3
60 : edgomez 442 /*****************************************************************************
61 :     * Function pointers
62 :     ****************************************************************************/
63 :    
64 : Isibaar 3 quant_intraFuncPtr quant4_intra;
65 :     quant_intraFuncPtr dequant4_intra;
66 :     dequant_interFuncPtr dequant4_inter;
67 :     quant_interFuncPtr quant4_inter;
68 :    
69 :    
70 : edgomez 442 /*****************************************************************************
71 :     * Local data
72 :     ****************************************************************************/
73 :    
74 : Isibaar 3 #define DIV_DIV(A,B) ( (A) > 0 ? ((A)+((B)>>1))/(B) : ((A)-((B)>>1))/(B) )
75 :     #define SIGN(A) ((A)>0?1:-1)
76 :     #define VM18P 3
77 :     #define VM18Q 4
78 :    
79 :    
80 : edgomez 442 /*
81 :     * divide-by-multiply table
82 :     * need 17 bit shift (16 causes slight errors when q > 19)
83 :     */
84 : Isibaar 3
85 :     #define SCALEBITS 17
86 :     #define FIX(X) ((1UL << SCALEBITS) / (X) + 1)
87 :    
88 : edgomez 195 static const uint32_t multipliers[32] = {
89 :     0, FIX(2), FIX(4), FIX(6),
90 :     FIX(8), FIX(10), FIX(12), FIX(14),
91 :     FIX(16), FIX(18), FIX(20), FIX(22),
92 :     FIX(24), FIX(26), FIX(28), FIX(30),
93 :     FIX(32), FIX(34), FIX(36), FIX(38),
94 :     FIX(40), FIX(42), FIX(44), FIX(46),
95 :     FIX(48), FIX(50), FIX(52), FIX(54),
96 :     FIX(56), FIX(58), FIX(60), FIX(62)
97 :     };
98 : Isibaar 3
99 : edgomez 442 /*****************************************************************************
100 :     * Functions
101 :     ****************************************************************************/
102 :    
103 : edgomez 677 #if 0
104 :     /* quantize intra-block */
105 : Isibaar 3
106 :     // const int32_t quantd = DIV_DIV(VM18P*quant, VM18Q);
107 :     //
108 :     // level = DIV_DIV(16 * data[i], default_intra_matrix[i]);
109 :     // coeff[i] = (level + quantd) / quant2;
110 : edgomez 677 #endif
111 : Isibaar 3
112 : edgomez 195 void
113 :     quant4_intra_c(int16_t * coeff,
114 :     const int16_t * data,
115 :     const uint32_t quant,
116 :     const uint32_t dcscalar)
117 : Isibaar 3 {
118 : edgomez 195 const uint32_t quantd = ((VM18P * quant) + (VM18Q / 2)) / VM18Q;
119 :     const uint32_t mult = multipliers[quant];
120 :     uint32_t i;
121 : Isibaar 4 int16_t *intra_matrix;
122 : Isibaar 3
123 : Isibaar 4 intra_matrix = get_intra_matrix();
124 :    
125 : edgomez 723 coeff[0] = (int16_t)(DIV_DIV(data[0], (int32_t) dcscalar));
126 : Isibaar 3
127 : edgomez 195 for (i = 1; i < 64; i++) {
128 :     if (data[i] < 0) {
129 :     uint32_t level = -data[i];
130 :    
131 :     level = ((level << 4) + (intra_matrix[i] >> 1)) / intra_matrix[i];
132 :     level = ((level + quantd) * mult) >> 17;
133 :     coeff[i] = -(int16_t) level;
134 :     } else if (data[i] > 0) {
135 :     uint32_t level = data[i];
136 :    
137 :     level = ((level << 4) + (intra_matrix[i] >> 1)) / intra_matrix[i];
138 :     level = ((level + quantd) * mult) >> 17;
139 : edgomez 723 coeff[i] = (int16_t)level;
140 : edgomez 195 } else {
141 :     coeff[i] = 0;
142 :     }
143 :     }
144 : Isibaar 3 }
145 :    
146 :    
147 :    
148 : edgomez 677 /* dequantize intra-block & clamp to [-2048,2047] */
149 :     /* data[i] = (coeff[i] * default_intra_matrix[i] * quant2) >> 4; */
150 : Isibaar 3
151 : edgomez 677
152 : edgomez 195 void
153 :     dequant4_intra_c(int16_t * data,
154 :     const int16_t * coeff,
155 :     const uint32_t quant,
156 :     const uint32_t dcscalar)
157 : Isibaar 3 {
158 : edgomez 195 uint32_t i;
159 : Isibaar 4 int16_t *intra_matrix;
160 :    
161 :     intra_matrix = get_intra_matrix();
162 : Isibaar 3
163 : edgomez 723 data[0] = (int16_t)(coeff[0] * dcscalar);
164 : edgomez 195 if (data[0] < -2048) {
165 :     data[0] = -2048;
166 :     } else if (data[0] > 2047) {
167 :     data[0] = 2047;
168 :     }
169 :    
170 :     for (i = 1; i < 64; i++) {
171 :     if (coeff[i] == 0) {
172 :     data[i] = 0;
173 :     } else if (coeff[i] < 0) {
174 :     uint32_t level = -coeff[i];
175 :    
176 :     level = (level * intra_matrix[i] * quant) >> 3;
177 :     data[i] = (level <= 2048 ? -(int16_t) level : -2048);
178 : edgomez 677 } else /* if (coeff[i] > 0) */
179 : edgomez 195 {
180 :     uint32_t level = coeff[i];
181 :    
182 :     level = (level * intra_matrix[i] * quant) >> 3;
183 : edgomez 723 data[i] = (int16_t)(level <= 2047 ? level : 2047);
184 : edgomez 195 }
185 :     }
186 : Isibaar 3 }
187 :    
188 :    
189 :    
190 : edgomez 677 #if 0
191 :     /* quantize inter-block */
192 : Isibaar 3
193 :     // level = DIV_DIV(16 * data[i], default_intra_matrix[i]);
194 :     // coeff[i] = (level + quantd) / quant2;
195 :     // sum += abs(level);
196 : edgomez 677 #endif
197 : Isibaar 3
198 : edgomez 195 uint32_t
199 :     quant4_inter_c(int16_t * coeff,
200 :     const int16_t * data,
201 :     const uint32_t quant)
202 : Isibaar 3 {
203 : edgomez 195 const uint32_t mult = multipliers[quant];
204 :     uint32_t sum = 0;
205 :     uint32_t i;
206 : Isibaar 4 int16_t *inter_matrix;
207 :    
208 :     inter_matrix = get_inter_matrix();
209 : edgomez 195
210 :     for (i = 0; i < 64; i++) {
211 :     if (data[i] < 0) {
212 :     uint32_t level = -data[i];
213 :    
214 :     level = ((level << 4) + (inter_matrix[i] >> 1)) / inter_matrix[i];
215 :     level = (level * mult) >> 17;
216 :     sum += level;
217 :     coeff[i] = -(int16_t) level;
218 :     } else if (data[i] > 0) {
219 :     uint32_t level = data[i];
220 :    
221 :     level = ((level << 4) + (inter_matrix[i] >> 1)) / inter_matrix[i];
222 :     level = (level * mult) >> 17;
223 :     sum += level;
224 : edgomez 723 coeff[i] = (int16_t)level;
225 : edgomez 195 } else {
226 :     coeff[i] = 0;
227 :     }
228 :     }
229 :     return sum;
230 : Isibaar 3 }
231 :    
232 :    
233 :    
234 :     /* dequantize inter-block & clamp to [-2048,2047]
235 :     data = ((2 * coeff + SIGN(coeff)) * inter_matrix[i] * quant) / 16
236 :     */
237 :    
238 : edgomez 195 void
239 :     dequant4_inter_c(int16_t * data,
240 :     const int16_t * coeff,
241 :     const uint32_t quant)
242 : Isibaar 3 {
243 : edgomez 195 uint32_t sum = 0;
244 :     uint32_t i;
245 : Isibaar 4 int16_t *inter_matrix;
246 :    
247 :     inter_matrix = get_inter_matrix();
248 : Isibaar 3
249 : edgomez 195 for (i = 0; i < 64; i++) {
250 :     if (coeff[i] == 0) {
251 :     data[i] = 0;
252 :     } else if (coeff[i] < 0) {
253 :     int32_t level = -coeff[i];
254 : Isibaar 3
255 : edgomez 195 level = ((2 * level + 1) * inter_matrix[i] * quant) >> 4;
256 :     data[i] = (level <= 2048 ? -level : -2048);
257 : edgomez 677 } else /* if (coeff[i] > 0) */
258 : edgomez 195 {
259 :     uint32_t level = coeff[i];
260 : Isibaar 3
261 : edgomez 195 level = ((2 * level + 1) * inter_matrix[i] * quant) >> 4;
262 : edgomez 723 data[i] = (int16_t)(level <= 2047 ? level : 2047);
263 : edgomez 195 }
264 :    
265 :     sum ^= data[i];
266 :     }
267 :    
268 : edgomez 677 /* mismatch control */
269 : edgomez 195
270 :     if ((sum & 1) == 0) {
271 :     data[63] ^= 1;
272 :     }
273 : Isibaar 3 }

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4