[svn] / branches / dev-api-4 / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/src/utils/mbtransquant.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 914 - (view) (download)

1 : edgomez 851 /******************************************************************************
2 :     * *
3 :     * This file is part of XviD, a free MPEG-4 video encoder/decoder *
4 :     * *
5 :     * XviD is an implementation of a part of one or more MPEG-4 Video tools *
6 :     * as specified in ISO/IEC 14496-2 standard. Those intending to use this *
7 :     * software module in hardware or software products are advised that its *
8 :     * use may infringe existing patents or copyrights, and any such use *
9 :     * would be at such party's own risk. The original developer of this *
10 :     * software module and his/her company, and subsequent editors and their *
11 :     * companies, will have no liability for use of this software or *
12 :     * modifications or derivatives thereof. *
13 :     * *
14 :     * XviD is free software; you can redistribute it and/or modify it *
15 :     * under the terms of the GNU General Public License as published by *
16 :     * the Free Software Foundation; either version 2 of the License, or *
17 :     * (at your option) any later version. *
18 :     * *
19 :     * XviD is distributed in the hope that it will be useful, but *
20 :     * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 :     * GNU General Public License for more details. *
23 :     * *
24 :     * You should have received a copy of the GNU General Public License *
25 :     * along with this program; if not, write to the Free Software *
26 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
27 :     * *
28 :     ******************************************************************************/
29 : Isibaar 3
30 : edgomez 851 /******************************************************************************
31 :     * *
32 :     * mbtransquant.c *
33 :     * *
34 :     * Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au> *
35 :     * Copyright (C) 2001 - Michael Militzer <isibaar@xvid.org> *
36 :     * *
37 :     * For more information visit the XviD homepage: http://www.xvid.org *
38 :     * *
39 :     ******************************************************************************/
40 :    
41 :     /******************************************************************************
42 :     * *
43 :     * Revision history: *
44 :     * *
45 :     * 29.03.2002 interlacing speedup - used transfer strides instead of *
46 :     * manual field-to-frame conversion *
47 :     * 26.03.2002 interlacing support - moved transfers outside loops *
48 :     * 22.12.2001 get_dc_scaler() moved to common.h *
49 :     * 19.11.2001 introduced coefficient thresholding (Isibaar) *
50 :     * 17.11.2001 initial version *
51 :     * *
52 :     ******************************************************************************/
53 :    
54 : edgomez 78 #include <string.h>
55 :    
56 : Isibaar 3 #include "../portab.h"
57 :     #include "mbfunctions.h"
58 :    
59 :     #include "../global.h"
60 :     #include "mem_transfer.h"
61 :     #include "timer.h"
62 :     #include "../dct/fdct.h"
63 :     #include "../dct/idct.h"
64 :     #include "../quant/quant_mpeg4.h"
65 :     #include "../quant/quant_h263.h"
66 :     #include "../encoder.h"
67 :    
68 : edgomez 851 #include "../image/reduced.h"
69 : Isibaar 3
70 : edgomez 851 MBFIELDTEST_PTR MBFieldTest;
71 : Isibaar 3
72 : edgomez 851 #define TOOSMALL_LIMIT 1 /* skip blocks having a coefficient sum below this value */
73 : Isibaar 3
74 : edgomez 195 void
75 :     MBTransQuantIntra(const MBParam * pParam,
76 :     FRAMEINFO * frame,
77 :     MACROBLOCK * pMB,
78 :     const uint32_t x_pos,
79 :     const uint32_t y_pos,
80 :     int16_t data[6 * 64],
81 :     int16_t qcoeff[6 * 64])
82 : Isibaar 3 {
83 : edgomez 78
84 : h 82 uint32_t stride = pParam->edged_width;
85 :     uint32_t stride2 = stride / 2;
86 : suxen_drol 890 uint32_t next_block = stride * ((frame->vop_flags & XVID_REDUCED)?16:8);
87 : Isibaar 3 uint32_t i;
88 : suxen_drol 136 uint32_t iQuant = frame->quant;
89 : Isibaar 3 uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
90 : edgomez 195 IMAGE *pCurrent = &frame->image;
91 : Isibaar 3
92 : edgomez 851 start_timer();
93 : suxen_drol 890 if ((frame->vop_flags & XVID_REDUCED))
94 : edgomez 851 {
95 :     pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
96 :     pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
97 :     pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
98 : h 69
99 : edgomez 851 filter_18x18_to_8x8(&data[0 * 64], pY_Cur, stride);
100 :     filter_18x18_to_8x8(&data[1 * 64], pY_Cur + 16, stride);
101 :     filter_18x18_to_8x8(&data[2 * 64], pY_Cur + next_block, stride);
102 :     filter_18x18_to_8x8(&data[3 * 64], pY_Cur + next_block + 16, stride);
103 :     filter_18x18_to_8x8(&data[4 * 64], pU_Cur, stride2);
104 :     filter_18x18_to_8x8(&data[5 * 64], pV_Cur, stride2);
105 :     }else{
106 :     pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
107 :     pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
108 :     pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
109 :    
110 :     transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
111 :     transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
112 :     transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
113 :     transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
114 :     transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
115 :     transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
116 :     }
117 : h 69 stop_transfer_timer();
118 :    
119 : edgomez 851 /* XXX: rrv+interlacing is buggy */
120 : h 69 start_timer();
121 :     pMB->field_dct = 0;
122 : suxen_drol 890 if ((frame->vol_flags & XVID_INTERLACING) &&
123 : h 390 (x_pos>0) && (x_pos<pParam->mb_width-1) &&
124 :     (y_pos>0) && (y_pos<pParam->mb_height-1)) {
125 : h 69 pMB->field_dct = MBDecideFieldDCT(data);
126 :     }
127 :     stop_interlacing_timer();
128 :    
129 : edgomez 195 for (i = 0; i < 6; i++) {
130 : Isibaar 3 uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
131 :    
132 :     start_timer();
133 : edgomez 195 fdct(&data[i * 64]);
134 : Isibaar 3 stop_dct_timer();
135 :    
136 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
137 : Isibaar 3 start_timer();
138 : edgomez 195 quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
139 : Isibaar 3 stop_quant_timer();
140 : edgomez 195 } else {
141 : Isibaar 3 start_timer();
142 : edgomez 195 quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
143 : Isibaar 3 stop_quant_timer();
144 : edgomez 851 }
145 : Isibaar 3
146 : edgomez 851 /* speedup: dont decode when encoding only ivops */
147 :     if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
148 :     {
149 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
150 : edgomez 851 start_timer();
151 :     dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
152 :     stop_iquant_timer();
153 :     } else {
154 :     start_timer();
155 :     dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
156 :     stop_iquant_timer();
157 :     }
158 :    
159 : Isibaar 3 start_timer();
160 : edgomez 851 idct(&data[i * 64]);
161 :     stop_idct_timer();
162 : Isibaar 3 }
163 : edgomez 851 }
164 : Isibaar 3
165 : edgomez 851 /* speedup: dont decode when encoding only ivops */
166 :     if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
167 :     {
168 :    
169 :     if (pMB->field_dct) {
170 :     next_block = stride;
171 :     stride *= 2;
172 :     }
173 :    
174 : Isibaar 3 start_timer();
175 : suxen_drol 890 if ((frame->vop_flags & XVID_REDUCED))
176 : edgomez 851 {
177 :     copy_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
178 :     copy_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
179 :     copy_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
180 :     copy_upsampled_8x8_16to8(pY_Cur + next_block + 16, &data[3 * 64], stride);
181 :     copy_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
182 :     copy_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
183 : Isibaar 3
184 : edgomez 851 }else{
185 :     transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
186 :     transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
187 :     transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
188 :     transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
189 :     transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
190 :     transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
191 :     }
192 :     stop_transfer_timer();
193 : h 69 }
194 :    
195 : Isibaar 3 }
196 :    
197 :    
198 : edgomez 195 uint8_t
199 :     MBTransQuantInter(const MBParam * pParam,
200 :     FRAMEINFO * frame,
201 :     MACROBLOCK * pMB,
202 :     const uint32_t x_pos,
203 :     const uint32_t y_pos,
204 :     int16_t data[6 * 64],
205 :     int16_t qcoeff[6 * 64])
206 : Isibaar 3 {
207 : edgomez 78
208 : h 82 uint32_t stride = pParam->edged_width;
209 :     uint32_t stride2 = stride / 2;
210 : suxen_drol 890 uint32_t next_block = stride * ((frame->vop_flags & XVID_REDUCED)?16:8);
211 : edgomez 78 uint32_t i;
212 : suxen_drol 136 uint32_t iQuant = frame->quant;
213 : Isibaar 3 uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
214 : edgomez 78 uint8_t cbp = 0;
215 : Isibaar 3 uint32_t sum;
216 : edgomez 195 IMAGE *pCurrent = &frame->image;
217 :    
218 : suxen_drol 890 if ((frame->vop_flags & XVID_REDUCED))
219 : edgomez 851 {
220 :     pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
221 :     pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
222 :     pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
223 :     }else{
224 :     pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
225 :     pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
226 :     pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
227 :     }
228 : Isibaar 3
229 : h 69 start_timer();
230 :     pMB->field_dct = 0;
231 : suxen_drol 890 if ((frame->vol_flags & XVID_INTERLACING) &&
232 : h 390 (x_pos>0) && (x_pos<pParam->mb_width-1) &&
233 :     (y_pos>0) && (y_pos<pParam->mb_height-1)) {
234 : h 69 pMB->field_dct = MBDecideFieldDCT(data);
235 :     }
236 :     stop_interlacing_timer();
237 :    
238 : edgomez 195 for (i = 0; i < 6; i++) {
239 : edgomez 851 uint32_t increase_limit = (iQuant == 1) ? 1 : 0;
240 :    
241 : Isibaar 3 /*
242 : edgomez 78 * no need to transfer 8->16-bit
243 :     * (this is performed already in motion compensation)
244 :     */
245 : Isibaar 3 start_timer();
246 : edgomez 195 fdct(&data[i * 64]);
247 : Isibaar 3 stop_dct_timer();
248 :    
249 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
250 : Isibaar 3 start_timer();
251 : edgomez 195 sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
252 : Isibaar 3 stop_quant_timer();
253 : edgomez 195 } else {
254 : Isibaar 3 start_timer();
255 : edgomez 195 sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
256 : Isibaar 3 stop_quant_timer();
257 :     }
258 :    
259 : edgomez 851 if ((sum >= TOOSMALL_LIMIT + increase_limit) || (qcoeff[i*64] != 0) ||
260 : Isibaar 375 (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {
261 : Isibaar 3
262 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
263 : Isibaar 3 start_timer();
264 : edgomez 195 dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
265 : Isibaar 3 stop_iquant_timer();
266 : edgomez 195 } else {
267 : Isibaar 3 start_timer();
268 : edgomez 195 dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
269 : Isibaar 3 stop_iquant_timer();
270 :     }
271 :    
272 :     cbp |= 1 << (5 - i);
273 :    
274 :     start_timer();
275 : edgomez 195 idct(&data[i * 64]);
276 : Isibaar 3 stop_idct_timer();
277 :     }
278 :     }
279 : h 69
280 : edgomez 195 if (pMB->field_dct) {
281 : h 82 next_block = stride;
282 :     stride *= 2;
283 : h 69 }
284 :    
285 :     start_timer();
286 : suxen_drol 890 if ((frame->vop_flags & XVID_REDUCED))
287 : edgomez 851 {
288 :     if (cbp & 32)
289 :     add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
290 :     if (cbp & 16)
291 :     add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
292 :     if (cbp & 8)
293 :     add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
294 :     if (cbp & 4)
295 :     add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);
296 :     if (cbp & 2)
297 :     add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
298 :     if (cbp & 1)
299 :     add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
300 :     }else{
301 :     if (cbp & 32)
302 :     transfer_16to8add(pY_Cur, &data[0 * 64], stride);
303 :     if (cbp & 16)
304 :     transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
305 :     if (cbp & 8)
306 :     transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
307 :     if (cbp & 4)
308 :     transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
309 :     if (cbp & 2)
310 :     transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
311 :     if (cbp & 1)
312 :     transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
313 :     }
314 : h 69 stop_transfer_timer();
315 :    
316 : edgomez 78 return cbp;
317 :    
318 : Isibaar 3 }
319 : h 69
320 : chl 368 void
321 :     MBTransQuantIntra2(const MBParam * pParam,
322 :     FRAMEINFO * frame,
323 :     MACROBLOCK * pMB,
324 :     const uint32_t x_pos,
325 :     const uint32_t y_pos,
326 :     int16_t data[6 * 64],
327 :     int16_t qcoeff[6 * 64])
328 :     {
329 :     MBTrans(pParam,frame,pMB,x_pos,y_pos,data);
330 :     MBfDCT(pParam,frame,pMB,data);
331 :     MBQuantIntra(pParam,frame,pMB,data,qcoeff);
332 :     MBDeQuantIntra(pParam,frame->quant,data,qcoeff);
333 :     MBiDCT(data,0x3F);
334 :     MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,0x3F);
335 :     }
336 : h 69
337 : chl 368
338 :     uint8_t
339 :     MBTransQuantInter2(const MBParam * pParam,
340 :     FRAMEINFO * frame,
341 :     MACROBLOCK * pMB,
342 :     const uint32_t x_pos,
343 :     const uint32_t y_pos,
344 :     int16_t data[6 * 64],
345 :     int16_t qcoeff[6 * 64])
346 :     {
347 :     uint8_t cbp;
348 :    
349 :     /* there is no MBTrans for Inter block, that's done in motion compensation already */
350 :    
351 :     MBfDCT(pParam,frame,pMB,data);
352 :     cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
353 :     MBDeQuantInter(pParam,frame->quant,data,qcoeff,cbp);
354 :     MBiDCT(data,cbp);
355 :     MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,cbp);
356 :    
357 :     return cbp;
358 :     }
359 :    
360 :     uint8_t
361 :     MBTransQuantInterBVOP(const MBParam * pParam,
362 :     FRAMEINFO * frame,
363 :     MACROBLOCK * pMB,
364 : edgomez 914 const uint32_t x_pos,
365 :     const uint32_t y_pos,
366 : chl 368 int16_t data[6 * 64],
367 :     int16_t qcoeff[6 * 64])
368 :     {
369 :     uint8_t cbp;
370 :    
371 :     /* there is no MBTrans for Inter block, that's done in motion compensation already */
372 :    
373 :     MBfDCT(pParam,frame,pMB,data);
374 :     cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
375 :    
376 : edgomez 914 /*
377 :     * History comment:
378 :     * we don't have to DeQuant, iDCT and Transfer back data for B-frames
379 :     */
380 : chl 368
381 : edgomez 914 /*
382 :     * As an exception to the previous rule, if we are willing to have extra
383 :     * stats then we have to DeQuant, iDCT and Transfer back the data :-)
384 :     */
385 :     if(frame->vop_flags & XVID_EXTRASTATS) {
386 :     MBDeQuantInter(pParam,frame->quant,data,qcoeff,cbp);
387 :     MBiDCT(data,cbp);
388 :     MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,cbp);
389 :     }
390 :    
391 : chl 368 return cbp;
392 :     }
393 :    
394 :    
395 :     void
396 :     MBfDCT(const MBParam * pParam,
397 :     FRAMEINFO * frame,
398 :     MACROBLOCK * pMB,
399 :     int16_t data[6 * 64])
400 :     {
401 :     int i;
402 :    
403 :     start_timer();
404 :     pMB->field_dct = 0;
405 : suxen_drol 890 if ((frame->vol_flags & XVID_INTERLACING)) {
406 : chl 368 pMB->field_dct = MBDecideFieldDCT(data);
407 :     }
408 :     stop_interlacing_timer();
409 :    
410 :     for (i = 0; i < 6; i++) {
411 :     start_timer();
412 :     fdct(&data[i * 64]);
413 :     stop_dct_timer();
414 :     }
415 :     }
416 :    
417 :     void
418 :     MBQuantDeQuantIntra(const MBParam * pParam,
419 :     FRAMEINFO * frame,
420 :     MACROBLOCK * pMB,
421 :     int16_t qcoeff[6 * 64],
422 :     int16_t data[6*64])
423 :     {
424 :     int i;
425 :     int iQuant = frame->quant;
426 :    
427 :     start_timer();
428 :     pMB->field_dct = 0;
429 : suxen_drol 890 if ((frame->vol_flags & XVID_INTERLACING)) {
430 : chl 368 pMB->field_dct = MBDecideFieldDCT(data);
431 :     }
432 :     stop_interlacing_timer();
433 :    
434 :     for (i = 0; i < 6; i++) {
435 :     uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
436 :    
437 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
438 : chl 368 start_timer();
439 :     quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
440 :     stop_quant_timer();
441 :    
442 :     start_timer();
443 :     dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
444 :     stop_iquant_timer();
445 :     } else {
446 :     start_timer();
447 :     quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
448 :     stop_quant_timer();
449 :    
450 :     start_timer();
451 :     dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
452 :     stop_iquant_timer();
453 :     }
454 :     }
455 :     }
456 :    
457 :     void
458 :     MBQuantIntra(const MBParam * pParam,
459 :     FRAMEINFO * frame,
460 :     MACROBLOCK *pMB,
461 : edgomez 851 int16_t qcoeff[6 * 64],
462 :     int16_t data[6*64])
463 : chl 368 {
464 :     int i;
465 :     int iQuant = frame->quant;
466 :    
467 :     start_timer();
468 :     pMB->field_dct = 0;
469 : suxen_drol 890 if ((frame->vol_flags & XVID_INTERLACING)) {
470 : chl 368 pMB->field_dct = MBDecideFieldDCT(data);
471 :     }
472 :     stop_interlacing_timer();
473 :    
474 :     for (i = 0; i < 6; i++) {
475 :     uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
476 :    
477 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
478 : chl 368 start_timer();
479 :     quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
480 :     stop_quant_timer();
481 :     } else {
482 :     start_timer();
483 :     quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
484 :     stop_quant_timer();
485 :     }
486 :     }
487 :     }
488 :    
489 :     void
490 :     MBDeQuantIntra(const MBParam * pParam,
491 :     const int iQuant,
492 :     int16_t qcoeff[6 * 64],
493 :     int16_t data[6*64])
494 :     {
495 :     int i;
496 :    
497 :     for (i = 0; i < 6; i++) {
498 :     uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
499 :    
500 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
501 : chl 368 start_timer();
502 :     dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
503 :     stop_iquant_timer();
504 :     } else {
505 :     start_timer();
506 :     dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
507 :     stop_iquant_timer();
508 :     }
509 :     }
510 :     }
511 :    
512 :     uint8_t
513 :     MBQuantInter(const MBParam * pParam,
514 :     const int iQuant,
515 :     int16_t data[6 * 64],
516 :     int16_t qcoeff[6 * 64])
517 :     {
518 :    
519 :     int i;
520 :     uint8_t cbp = 0;
521 :     int sum;
522 :    
523 :     for (i = 0; i < 6; i++) {
524 :    
525 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
526 : chl 368 start_timer();
527 :     sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
528 :     stop_quant_timer();
529 :     } else {
530 :     start_timer();
531 :     sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
532 :     stop_quant_timer();
533 :     }
534 :    
535 : edgomez 851 if (sum >= TOOSMALL_LIMIT) { // skip block ?
536 : chl 368 cbp |= 1 << (5 - i);
537 :     }
538 :     }
539 :     return cbp;
540 :     }
541 :    
542 :     void
543 :     MBDeQuantInter( const MBParam * pParam,
544 :     const int iQuant,
545 :     int16_t data[6 * 64],
546 :     int16_t qcoeff[6 * 64],
547 :     const uint8_t cbp)
548 :     {
549 :     int i;
550 :    
551 :     for (i = 0; i < 6; i++) {
552 :     if (cbp & (1 << (5 - i)))
553 :     {
554 : suxen_drol 890 if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
555 : chl 368 start_timer();
556 :     dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
557 :     stop_iquant_timer();
558 :     } else {
559 :     start_timer();
560 :     dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
561 :     stop_iquant_timer();
562 :     }
563 :     }
564 :     }
565 :     }
566 :    
567 :     void
568 :     MBiDCT( int16_t data[6 * 64],
569 :     const uint8_t cbp)
570 :     {
571 :     int i;
572 :    
573 :     for (i = 0; i < 6; i++) {
574 :     if (cbp & (1 << (5 - i)))
575 :     {
576 :     start_timer();
577 :     idct(&data[i * 64]);
578 :     stop_idct_timer();
579 :    
580 :     }
581 :     }
582 :     }
583 :    
584 :    
585 :     void
586 :     MBTrans(const MBParam * pParam,
587 :     FRAMEINFO * frame,
588 :     MACROBLOCK * pMB,
589 :     const uint32_t x_pos,
590 :     const uint32_t y_pos,
591 :     int16_t data[6 * 64])
592 :     {
593 :     uint32_t stride = pParam->edged_width;
594 :     uint32_t stride2 = stride / 2;
595 :     uint32_t next_block = stride * 8;
596 :     uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
597 :     IMAGE *pCurrent = &frame->image;
598 :    
599 :     pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
600 :     pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
601 :     pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
602 :    
603 :     start_timer();
604 :     transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
605 :     transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
606 :     transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
607 :     transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
608 :     transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
609 :     transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
610 :     stop_transfer_timer();
611 :     }
612 :    
613 :     void
614 :     MBTransAdd(const MBParam * pParam,
615 :     FRAMEINFO * frame,
616 :     MACROBLOCK * pMB,
617 :     const uint32_t x_pos,
618 :     const uint32_t y_pos,
619 :     int16_t data[6 * 64],
620 :     const uint8_t cbp)
621 :     {
622 :     uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
623 :     uint32_t stride = pParam->edged_width;
624 :     uint32_t stride2 = stride / 2;
625 :     uint32_t next_block = stride * 8;
626 :     IMAGE *pCurrent = &frame->image;
627 :    
628 :     pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
629 :     pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
630 :     pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
631 :    
632 :     if (pMB->field_dct) {
633 :     next_block = stride;
634 :     stride *= 2;
635 :     }
636 :    
637 :     start_timer();
638 :     if (cbp & 32)
639 :     transfer_16to8add(pY_Cur, &data[0 * 64], stride);
640 :     if (cbp & 16)
641 :     transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
642 :     if (cbp & 8)
643 :     transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
644 :     if (cbp & 4)
645 :     transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
646 :     if (cbp & 2)
647 :     transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
648 :     if (cbp & 1)
649 :     transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
650 :     stop_transfer_timer();
651 :     }
652 :    
653 :    
654 :    
655 : edgomez 851 /* permute block and return field dct choice */
656 : h 69
657 :    
658 : edgomez 195 uint32_t
659 :     MBDecideFieldDCT(int16_t data[6 * 64])
660 : h 69 {
661 : edgomez 851 uint32_t field = MBFieldTest(data);
662 : h 69
663 : edgomez 851 if (field) {
664 :     MBFrameToField(data);
665 :     }
666 :    
667 :     return field;
668 :     }
669 :    
670 :    
671 :     /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
672 :    
673 :     uint32_t
674 :     MBFieldTest_c(int16_t data[6 * 64])
675 :     {
676 : edgomez 195 const uint8_t blocks[] =
677 :     { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };
678 :     const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };
679 : edgomez 78
680 : h 69 int frame = 0, field = 0;
681 :     int i, j;
682 :    
683 : edgomez 195 for (i = 0; i < 7; ++i) {
684 :     for (j = 0; j < 8; ++j) {
685 :     frame +=
686 :     ABS(data[0 * 64 + (i + 1) * 8 + j] - data[0 * 64 + i * 8 + j]);
687 :     frame +=
688 :     ABS(data[1 * 64 + (i + 1) * 8 + j] - data[1 * 64 + i * 8 + j]);
689 :     frame +=
690 :     ABS(data[2 * 64 + (i + 1) * 8 + j] - data[2 * 64 + i * 8 + j]);
691 :     frame +=
692 :     ABS(data[3 * 64 + (i + 1) * 8 + j] - data[3 * 64 + i * 8 + j]);
693 : h 69
694 : edgomez 195 field +=
695 :     ABS(data[blocks[i + 1] + lines[i + 1] + j] -
696 :     data[blocks[i] + lines[i] + j]);
697 :     field +=
698 :     ABS(data[blocks[i + 1] + lines[i + 1] + 8 + j] -
699 :     data[blocks[i] + lines[i] + 8 + j]);
700 :     field +=
701 :     ABS(data[blocks[i + 1] + 64 + lines[i + 1] + j] -
702 :     data[blocks[i] + 64 + lines[i] + j]);
703 :     field +=
704 :     ABS(data[blocks[i + 1] + 64 + lines[i + 1] + 8 + j] -
705 :     data[blocks[i] + 64 + lines[i] + 8 + j]);
706 : h 69 }
707 :     }
708 :    
709 : edgomez 851 return (frame >= (field + 350));
710 : h 69 }
711 :    
712 :    
713 :     /* deinterlace Y blocks vertically */
714 :    
715 :     #define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
716 : edgomez 78 #define LINE(X,Y) &data[X*64 + Y*8]
717 : h 69
718 : edgomez 195 void
719 :     MBFrameToField(int16_t data[6 * 64])
720 : h 69 {
721 :     int16_t tmp[8];
722 :    
723 :     /* left blocks */
724 :    
725 : edgomez 851 // 1=2, 2=4, 4=8, 8=1
726 : edgomez 195 MOVLINE(tmp, LINE(0, 1));
727 :     MOVLINE(LINE(0, 1), LINE(0, 2));
728 :     MOVLINE(LINE(0, 2), LINE(0, 4));
729 :     MOVLINE(LINE(0, 4), LINE(2, 0));
730 :     MOVLINE(LINE(2, 0), tmp);
731 : h 69
732 : edgomez 851 // 3=6, 6=12, 12=9, 9=3
733 : edgomez 195 MOVLINE(tmp, LINE(0, 3));
734 :     MOVLINE(LINE(0, 3), LINE(0, 6));
735 :     MOVLINE(LINE(0, 6), LINE(2, 4));
736 :     MOVLINE(LINE(2, 4), LINE(2, 1));
737 :     MOVLINE(LINE(2, 1), tmp);
738 : h 69
739 : edgomez 851 // 5=10, 10=5
740 : edgomez 195 MOVLINE(tmp, LINE(0, 5));
741 :     MOVLINE(LINE(0, 5), LINE(2, 2));
742 :     MOVLINE(LINE(2, 2), tmp);
743 : h 69
744 : edgomez 851 // 7=14, 14=13, 13=11, 11=7
745 : edgomez 195 MOVLINE(tmp, LINE(0, 7));
746 :     MOVLINE(LINE(0, 7), LINE(2, 6));
747 :     MOVLINE(LINE(2, 6), LINE(2, 5));
748 :     MOVLINE(LINE(2, 5), LINE(2, 3));
749 :     MOVLINE(LINE(2, 3), tmp);
750 : h 69
751 :     /* right blocks */
752 :    
753 : edgomez 851 // 1=2, 2=4, 4=8, 8=1
754 : edgomez 195 MOVLINE(tmp, LINE(1, 1));
755 :     MOVLINE(LINE(1, 1), LINE(1, 2));
756 :     MOVLINE(LINE(1, 2), LINE(1, 4));
757 :     MOVLINE(LINE(1, 4), LINE(3, 0));
758 :     MOVLINE(LINE(3, 0), tmp);
759 : h 69
760 : edgomez 851 // 3=6, 6=12, 12=9, 9=3
761 : edgomez 195 MOVLINE(tmp, LINE(1, 3));
762 :     MOVLINE(LINE(1, 3), LINE(1, 6));
763 :     MOVLINE(LINE(1, 6), LINE(3, 4));
764 :     MOVLINE(LINE(3, 4), LINE(3, 1));
765 :     MOVLINE(LINE(3, 1), tmp);
766 : h 69
767 : edgomez 851 // 5=10, 10=5
768 : edgomez 195 MOVLINE(tmp, LINE(1, 5));
769 :     MOVLINE(LINE(1, 5), LINE(3, 2));
770 :     MOVLINE(LINE(3, 2), tmp);
771 : h 69
772 : edgomez 851 // 7=14, 14=13, 13=11, 11=7
773 : edgomez 195 MOVLINE(tmp, LINE(1, 7));
774 :     MOVLINE(LINE(1, 7), LINE(3, 6));
775 :     MOVLINE(LINE(3, 6), LINE(3, 5));
776 :     MOVLINE(LINE(3, 5), LINE(3, 3));
777 :     MOVLINE(LINE(3, 3), tmp);
778 : h 69 }

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