[svn] / trunk / xvidcore / src / prediction / mbprediction.c Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/src/prediction/mbprediction.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1988 - (view) (download)

1 : edgomez 1382 /*****************************************************************************
2 :     *
3 :     * XVID MPEG-4 VIDEO CODEC
4 :     * - Prediction module -
5 :     *
6 :     * Copyright (C) 2001-2003 Michael Militzer <isibaar@xvid.org>
7 :     * 2001-2003 Peter Ross <pross@xvid.org>
8 :     *
9 :     * This program is free software ; you can redistribute it and/or modify
10 :     * it under the terms of the GNU General Public License as published by
11 :     * the Free Software Foundation ; either version 2 of the License, or
12 :     * (at your option) any later version.
13 :     *
14 :     * This program is distributed in the hope that it will be useful,
15 :     * but WITHOUT ANY WARRANTY ; without even the implied warranty of
16 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 :     * GNU General Public License for more details.
18 :     *
19 :     * You should have received a copy of the GNU General Public License
20 :     * along with this program ; if not, write to the Free Software
21 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 :     *
23 : Isibaar 1988 * $Id$
24 : edgomez 1382 *
25 :     ****************************************************************************/
26 : Isibaar 3
27 : edgomez 1382 #include <stdlib.h>
28 : edgomez 851
29 :     #include "../global.h"
30 : Isibaar 3 #include "../encoder.h"
31 :     #include "mbprediction.h"
32 :     #include "../utils/mbfunctions.h"
33 :     #include "../bitstream/cbp.h"
34 : edgomez 851 #include "../bitstream/mbcoding.h"
35 :     #include "../bitstream/zigzag.h"
36 : Isibaar 3
37 :    
38 : edgomez 195 static int __inline
39 :     rescale(int predict_quant,
40 :     int current_quant,
41 :     int coeff)
42 : Isibaar 3 {
43 : edgomez 195 return (coeff != 0) ? DIV_DIV((coeff) * (predict_quant),
44 :     (current_quant)) : 0;
45 : Isibaar 3 }
46 :    
47 :    
48 : edgomez 195 static const int16_t default_acdc_values[15] = {
49 : Isibaar 3 1024,
50 : edgomez 78 0, 0, 0, 0, 0, 0, 0,
51 :     0, 0, 0, 0, 0, 0, 0
52 : Isibaar 3 };
53 :    
54 :    
55 :     /* get dc/ac prediction direction for a single block and place
56 :     predictor values into MB->pred_values[j][..]
57 :     */
58 :    
59 :    
60 : edgomez 195 void
61 :     predict_acdc(MACROBLOCK * pMBs,
62 :     uint32_t x,
63 :     uint32_t y,
64 :     uint32_t mb_width,
65 :     uint32_t block,
66 :     int16_t qcoeff[64],
67 :     uint32_t current_quant,
68 :     int32_t iDcScaler,
69 : suxen_drol 248 int16_t predictors[8],
70 : edgomez 1472 const int bound)
71 : suxen_drol 248
72 : Isibaar 3 {
73 : suxen_drol 252 const int mbpos = (y * mb_width) + x;
74 : edgomez 78 int16_t *left, *top, *diag, *current;
75 : Isibaar 3
76 : edgomez 78 int32_t left_quant = current_quant;
77 :     int32_t top_quant = current_quant;
78 : Isibaar 3
79 : edgomez 78 const int16_t *pLeft = default_acdc_values;
80 :     const int16_t *pTop = default_acdc_values;
81 :     const int16_t *pDiag = default_acdc_values;
82 : Isibaar 3
83 : edgomez 1382 uint32_t index = x + y * mb_width; /* current macroblock */
84 : edgomez 195 int *acpred_direction = &pMBs[index].acpred_directions[block];
85 : Isibaar 3 uint32_t i;
86 :    
87 : suxen_drol 1653 left = top = diag = current = NULL;
88 : Isibaar 3
89 : edgomez 1382 /* grab left,top and diag macroblocks */
90 : Isibaar 3
91 : edgomez 1382 /* left macroblock */
92 : Isibaar 3
93 : suxen_drol 248 if (x && mbpos >= bound + 1 &&
94 : edgomez 195 (pMBs[index - 1].mode == MODE_INTRA ||
95 :     pMBs[index - 1].mode == MODE_INTRA_Q)) {
96 : Isibaar 3
97 : suxen_drol 1653 left = (int16_t*)pMBs[index - 1].pred_values[0];
98 : Isibaar 3 left_quant = pMBs[index - 1].quant;
99 :     }
100 : edgomez 1382 /* top macroblock */
101 : Isibaar 3
102 : suxen_drol 252 if (mbpos >= bound + (int)mb_width &&
103 : edgomez 195 (pMBs[index - mb_width].mode == MODE_INTRA ||
104 :     pMBs[index - mb_width].mode == MODE_INTRA_Q)) {
105 :    
106 : suxen_drol 1653 top = (int16_t*)pMBs[index - mb_width].pred_values[0];
107 : Isibaar 3 top_quant = pMBs[index - mb_width].quant;
108 : edgomez 78 }
109 : edgomez 1382 /* diag macroblock */
110 : Isibaar 3
111 : suxen_drol 252 if (x && mbpos >= bound + (int)mb_width + 1 &&
112 : edgomez 195 (pMBs[index - 1 - mb_width].mode == MODE_INTRA ||
113 :     pMBs[index - 1 - mb_width].mode == MODE_INTRA_Q)) {
114 :    
115 : suxen_drol 1653 diag = (int16_t*)pMBs[index - 1 - mb_width].pred_values[0];
116 : Isibaar 3 }
117 :    
118 : suxen_drol 1653 current = (int16_t*)pMBs[index].pred_values[0];
119 : Isibaar 3
120 : edgomez 1382 /* now grab pLeft, pTop, pDiag _blocks_ */
121 : edgomez 195
122 : Isibaar 3 switch (block) {
123 : edgomez 195
124 :     case 0:
125 :     if (left)
126 : Isibaar 3 pLeft = left + MBPRED_SIZE;
127 : edgomez 195
128 :     if (top)
129 : Isibaar 3 pTop = top + (MBPRED_SIZE << 1);
130 : edgomez 195
131 :     if (diag)
132 : Isibaar 3 pDiag = diag + 3 * MBPRED_SIZE;
133 : edgomez 195
134 : Isibaar 3 break;
135 : edgomez 195
136 : Isibaar 3 case 1:
137 :     pLeft = current;
138 :     left_quant = current_quant;
139 : edgomez 195
140 :     if (top) {
141 : Isibaar 3 pTop = top + 3 * MBPRED_SIZE;
142 :     pDiag = top + (MBPRED_SIZE << 1);
143 :     }
144 :     break;
145 : edgomez 195
146 : Isibaar 3 case 2:
147 : edgomez 195 if (left) {
148 : Isibaar 3 pLeft = left + 3 * MBPRED_SIZE;
149 :     pDiag = left + MBPRED_SIZE;
150 :     }
151 : edgomez 195
152 : Isibaar 3 pTop = current;
153 :     top_quant = current_quant;
154 :    
155 :     break;
156 : edgomez 195
157 : Isibaar 3 case 3:
158 :     pLeft = current + (MBPRED_SIZE << 1);
159 :     left_quant = current_quant;
160 : edgomez 195
161 : Isibaar 3 pTop = current + MBPRED_SIZE;
162 :     top_quant = current_quant;
163 : edgomez 195
164 : Isibaar 3 pDiag = current;
165 : edgomez 195
166 : Isibaar 3 break;
167 : edgomez 195
168 : Isibaar 3 case 4:
169 : edgomez 195 if (left)
170 : Isibaar 3 pLeft = left + (MBPRED_SIZE << 2);
171 : edgomez 195 if (top)
172 : Isibaar 3 pTop = top + (MBPRED_SIZE << 2);
173 : edgomez 195 if (diag)
174 : Isibaar 3 pDiag = diag + (MBPRED_SIZE << 2);
175 :     break;
176 : edgomez 195
177 : Isibaar 3 case 5:
178 : edgomez 195 if (left)
179 : Isibaar 3 pLeft = left + 5 * MBPRED_SIZE;
180 : edgomez 195 if (top)
181 : Isibaar 3 pTop = top + 5 * MBPRED_SIZE;
182 : edgomez 195 if (diag)
183 : Isibaar 3 pDiag = diag + 5 * MBPRED_SIZE;
184 :     break;
185 :     }
186 :    
187 : edgomez 1451 /* determine ac prediction direction & ac/dc predictor place rescaled ac/dc
188 :     * predictions into predictors[] for later use */
189 : edgomez 1382 if (abs(pLeft[0] - pDiag[0]) < abs(pDiag[0] - pTop[0])) {
190 :     *acpred_direction = 1; /* vertical */
191 : edgomez 851 predictors[0] = DIV_DIV(pTop[0], iDcScaler);
192 : edgomez 195 for (i = 1; i < 8; i++) {
193 : Isibaar 3 predictors[i] = rescale(top_quant, current_quant, pTop[i]);
194 :     }
195 : edgomez 195 } else {
196 : edgomez 1382 *acpred_direction = 2; /* horizontal */
197 : edgomez 851 predictors[0] = DIV_DIV(pLeft[0], iDcScaler);
198 : edgomez 195 for (i = 1; i < 8; i++) {
199 : Isibaar 3 predictors[i] = rescale(left_quant, current_quant, pLeft[i + 7]);
200 :     }
201 :     }
202 :     }
203 :    
204 :    
205 :     /* decoder: add predictors to dct_codes[] and
206 : edgomez 1382 store current coeffs to pred_values[] for future prediction
207 : Isibaar 3 */
208 :    
209 : edgomez 1472 /* Up to this version, no DC clipping was performed, so we try to be backward
210 :     * compatible to avoid artifacts */
211 :     #define BS_VERSION_BUGGY_DC_CLIPPING 34
212 : Isibaar 3
213 : edgomez 195 void
214 :     add_acdc(MACROBLOCK * pMB,
215 :     uint32_t block,
216 :     int16_t dct_codes[64],
217 :     uint32_t iDcScaler,
218 : edgomez 1472 int16_t predictors[8],
219 :     const int bsversion)
220 : Isibaar 3 {
221 :     uint8_t acpred_direction = pMB->acpred_directions[block];
222 : suxen_drol 1653 int16_t *pCurrent = (int16_t*)pMB->pred_values[block];
223 : Isibaar 3 uint32_t i;
224 :    
225 : edgomez 1382 DPRINTF(XVID_DEBUG_COEFF,"predictor[0] %i\n", predictors[0]);
226 : suxen_drol 252
227 : edgomez 1382 dct_codes[0] += predictors[0]; /* dc prediction */
228 : edgomez 1472 pCurrent[0] = dct_codes[0]*iDcScaler;
229 : Isibaar 1891 if (bsversion > BS_VERSION_BUGGY_DC_CLIPPING) {
230 : edgomez 1472 pCurrent[0] = CLIP(pCurrent[0], -2048, 2047);
231 :     }
232 : Isibaar 3
233 : edgomez 195 if (acpred_direction == 1) {
234 :     for (i = 1; i < 8; i++) {
235 : Isibaar 3 int level = dct_codes[i] + predictors[i];
236 : edgomez 195
237 : edgomez 1382 DPRINTF(XVID_DEBUG_COEFF,"predictor[%i] %i\n",i, predictors[i]);
238 : suxen_drol 252
239 : Isibaar 3 dct_codes[i] = level;
240 :     pCurrent[i] = level;
241 : edgomez 195 pCurrent[i + 7] = dct_codes[i * 8];
242 : Isibaar 3 }
243 : edgomez 195 } else if (acpred_direction == 2) {
244 :     for (i = 1; i < 8; i++) {
245 :     int level = dct_codes[i * 8] + predictors[i];
246 : edgomez 1382 DPRINTF(XVID_DEBUG_COEFF,"predictor[%i] %i\n",i*8, predictors[i]);
247 : edgomez 195
248 :     dct_codes[i * 8] = level;
249 :     pCurrent[i + 7] = level;
250 : Isibaar 3 pCurrent[i] = dct_codes[i];
251 :     }
252 : edgomez 195 } else {
253 :     for (i = 1; i < 8; i++) {
254 : Isibaar 3 pCurrent[i] = dct_codes[i];
255 : edgomez 195 pCurrent[i + 7] = dct_codes[i * 8];
256 : Isibaar 3 }
257 :     }
258 :     }
259 :    
260 :    
261 :    
262 : edgomez 1382 /*****************************************************************************
263 :     ****************************************************************************/
264 : Isibaar 3
265 :     /* encoder: subtract predictors from qcoeff[] and calculate S1/S2
266 :    
267 : edgomez 851 returns sum of coeefficients *saved* if prediction is enabled
268 :    
269 : edgomez 78 S1 = sum of all (qcoeff - prediction)
270 :     S2 = sum of all qcoeff
271 :     */
272 : Isibaar 3
273 : suxen_drol 1653 static int
274 : edgomez 851 calc_acdc_coeff(MACROBLOCK * pMB,
275 : edgomez 195 uint32_t block,
276 :     int16_t qcoeff[64],
277 :     uint32_t iDcScaler,
278 :     int16_t predictors[8])
279 : Isibaar 3 {
280 : suxen_drol 1653 int16_t *pCurrent = (int16_t*)pMB->pred_values[block];
281 : Isibaar 3 uint32_t i;
282 : edgomez 851 int S1 = 0, S2 = 0;
283 : Isibaar 3
284 :    
285 :     /* store current coeffs to pred_values[] for future prediction */
286 :    
287 : edgomez 851 pCurrent[0] = qcoeff[0] * iDcScaler;
288 : edgomez 1472 pCurrent[0] = CLIP(pCurrent[0], -2048, 2047);
289 : edgomez 195 for (i = 1; i < 8; i++) {
290 : Isibaar 3 pCurrent[i] = qcoeff[i];
291 :     pCurrent[i + 7] = qcoeff[i * 8];
292 : edgomez 78 }
293 : Isibaar 3
294 :     /* subtract predictors and store back in predictors[] */
295 :    
296 :     qcoeff[0] = qcoeff[0] - predictors[0];
297 :    
298 : edgomez 195 if (pMB->acpred_directions[block] == 1) {
299 :     for (i = 1; i < 8; i++) {
300 : Isibaar 3 int16_t level;
301 :    
302 :     level = qcoeff[i];
303 : edgomez 1382 S2 += abs(level);
304 : Isibaar 3 level -= predictors[i];
305 : edgomez 1382 S1 += abs(level);
306 : Isibaar 3 predictors[i] = level;
307 :     }
308 : edgomez 1382 } else /* acpred_direction == 2 */
309 : Isibaar 3 {
310 : edgomez 195 for (i = 1; i < 8; i++) {
311 : Isibaar 3 int16_t level;
312 :    
313 : edgomez 195 level = qcoeff[i * 8];
314 : edgomez 1382 S2 += abs(level);
315 : Isibaar 3 level -= predictors[i];
316 : edgomez 1382 S1 += abs(level);
317 : Isibaar 3 predictors[i] = level;
318 :     }
319 :    
320 : edgomez 78 }
321 : Isibaar 3
322 : edgomez 195
323 : edgomez 78 return S2 - S1;
324 : Isibaar 3 }
325 :    
326 :    
327 : edgomez 851
328 :     /* returns the bits *saved* if prediction is enabled */
329 :    
330 : suxen_drol 1653 static int
331 : edgomez 851 calc_acdc_bits(MACROBLOCK * pMB,
332 :     uint32_t block,
333 :     int16_t qcoeff[64],
334 :     uint32_t iDcScaler,
335 :     int16_t predictors[8])
336 :     {
337 :     const int direction = pMB->acpred_directions[block];
338 : suxen_drol 1653 int16_t *pCurrent = (int16_t*)pMB->pred_values[block];
339 : edgomez 851 int16_t tmp[8];
340 :     unsigned int i;
341 :     int Z1, Z2;
342 :    
343 :     /* store current coeffs to pred_values[] for future prediction */
344 :     pCurrent[0] = qcoeff[0] * iDcScaler;
345 : edgomez 1472 pCurrent[0] = CLIP(pCurrent[0], -2048, 2047);
346 : edgomez 851 for (i = 1; i < 8; i++) {
347 :     pCurrent[i] = qcoeff[i];
348 :     pCurrent[i + 7] = qcoeff[i * 8];
349 :     }
350 :    
351 :    
352 :     /* dc prediction */
353 :     qcoeff[0] = qcoeff[0] - predictors[0];
354 :    
355 :     /* calc cost before ac prediction */
356 :     Z2 = CodeCoeffIntra_CalcBits(qcoeff, scan_tables[0]);
357 :    
358 :     /* apply ac prediction & calc cost*/
359 :     if (direction == 1) {
360 :     for (i = 1; i < 8; i++) {
361 :     tmp[i] = qcoeff[i];
362 :     qcoeff[i] -= predictors[i];
363 :     predictors[i] = qcoeff[i];
364 :     }
365 : edgomez 1382 }else{ /* acpred_direction == 2 */
366 : edgomez 851 for (i = 1; i < 8; i++) {
367 :     tmp[i] = qcoeff[i*8];
368 :     qcoeff[i*8] -= predictors[i];
369 :     predictors[i] = qcoeff[i*8];
370 :     }
371 :     }
372 :    
373 :     Z1 = CodeCoeffIntra_CalcBits(qcoeff, scan_tables[direction]);
374 :    
375 :     /* undo prediction */
376 :     if (direction == 1) {
377 : edgomez 1382 for (i = 1; i < 8; i++)
378 : edgomez 851 qcoeff[i] = tmp[i];
379 : edgomez 1382 }else{ /* acpred_direction == 2 */
380 :     for (i = 1; i < 8; i++)
381 : edgomez 851 qcoeff[i*8] = tmp[i];
382 :     }
383 :    
384 :     return Z2-Z1;
385 :     }
386 :    
387 : Isibaar 3 /* apply predictors[] to qcoeff */
388 :    
389 : suxen_drol 1653 static void
390 : edgomez 195 apply_acdc(MACROBLOCK * pMB,
391 :     uint32_t block,
392 :     int16_t qcoeff[64],
393 :     int16_t predictors[8])
394 : Isibaar 3 {
395 : edgomez 851 unsigned int i;
396 : Isibaar 3
397 : edgomez 195 if (pMB->acpred_directions[block] == 1) {
398 : edgomez 1382 for (i = 1; i < 8; i++)
399 : Isibaar 3 qcoeff[i] = predictors[i];
400 : edgomez 195 } else {
401 : edgomez 1382 for (i = 1; i < 8; i++)
402 : edgomez 195 qcoeff[i * 8] = predictors[i];
403 : edgomez 78 }
404 : Isibaar 3 }
405 :    
406 :    
407 : edgomez 195 void
408 :     MBPrediction(FRAMEINFO * frame,
409 :     uint32_t x,
410 :     uint32_t y,
411 :     uint32_t mb_width,
412 : Isibaar 1913 int16_t qcoeff[6 * 64],
413 :     const int bound)
414 : Isibaar 3 {
415 : edgomez 78
416 :     int32_t j;
417 : edgomez 1382 int32_t iDcScaler, iQuant;
418 : edgomez 851 int S = 0;
419 : Isibaar 3 int16_t predictors[6][8];
420 :    
421 : suxen_drol 136 MACROBLOCK *pMB = &frame->mbs[x + y * mb_width];
422 : edgomez 1382 iQuant = pMB->quant;
423 : Isibaar 3
424 : edgomez 78 if ((pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q)) {
425 : edgomez 195
426 :     for (j = 0; j < 6; j++) {
427 : edgomez 851 iDcScaler = get_dc_scaler(iQuant, j<4);
428 : Isibaar 3
429 : edgomez 195 predict_acdc(frame->mbs, x, y, mb_width, j, &qcoeff[j * 64],
430 : Isibaar 1913 iQuant, iDcScaler, predictors[j], bound);
431 : edgomez 78
432 : edgomez 1382 if ((frame->vop_flags & XVID_VOP_HQACPRED))
433 : edgomez 851 S += calc_acdc_bits(pMB, j, &qcoeff[j * 64], iDcScaler, predictors[j]);
434 :     else
435 :     S += calc_acdc_coeff(pMB, j, &qcoeff[j * 64], iDcScaler, predictors[j]);
436 : edgomez 78
437 : Isibaar 3 }
438 :    
439 : edgomez 1382 if (S<=0) { /* dont predict */
440 : edgomez 851 for (j = 0; j < 6; j++)
441 : Isibaar 3 pMB->acpred_directions[j] = 0;
442 : edgomez 851 }else{
443 : edgomez 1382 for (j = 0; j < 6; j++)
444 : edgomez 195 apply_acdc(pMB, j, &qcoeff[j * 64], predictors[j]);
445 : Isibaar 3 }
446 : edgomez 1382
447 : Isibaar 3 pMB->cbp = calc_cbp(qcoeff);
448 :     }
449 : edgomez 1382 }
450 : edgomez 78
451 : edgomez 1382 static const VECTOR zeroMV = { 0, 0 };
452 :    
453 :     VECTOR
454 :     get_pmv2(const MACROBLOCK * const mbs,
455 :     const int mb_width,
456 :     const int bound,
457 :     const int x,
458 :     const int y,
459 :     const int block)
460 :     {
461 :     int lx, ly, lz; /* left */
462 :     int tx, ty, tz; /* top */
463 :     int rx, ry, rz; /* top-right */
464 :     int lpos, tpos, rpos;
465 :     int num_cand = 0, last_cand = 1;
466 :    
467 :     VECTOR pmv[4]; /* left neighbour, top neighbour, top-right neighbour */
468 :    
469 :     switch (block) {
470 :     case 0:
471 :     lx = x - 1; ly = y; lz = 1;
472 :     tx = x; ty = y - 1; tz = 2;
473 :     rx = x + 1; ry = y - 1; rz = 2;
474 :     break;
475 :     case 1:
476 :     lx = x; ly = y; lz = 0;
477 :     tx = x; ty = y - 1; tz = 3;
478 :     rx = x + 1; ry = y - 1; rz = 2;
479 :     break;
480 :     case 2:
481 :     lx = x - 1; ly = y; lz = 3;
482 :     tx = x; ty = y; tz = 0;
483 :     rx = x; ry = y; rz = 1;
484 :     break;
485 :     default:
486 :     lx = x; ly = y; lz = 2;
487 :     tx = x; ty = y; tz = 0;
488 :     rx = x; ry = y; rz = 1;
489 :     }
490 :    
491 :     lpos = lx + ly * mb_width;
492 :     rpos = rx + ry * mb_width;
493 :     tpos = tx + ty * mb_width;
494 :    
495 :     if (lpos >= bound && lx >= 0) {
496 :     num_cand++;
497 :     pmv[1] = mbs[lpos].mvs[lz];
498 :     } else pmv[1] = zeroMV;
499 :    
500 :     if (tpos >= bound) {
501 :     num_cand++;
502 :     last_cand = 2;
503 :     pmv[2] = mbs[tpos].mvs[tz];
504 :     } else pmv[2] = zeroMV;
505 :    
506 :     if (rpos >= bound && rx < mb_width) {
507 :     num_cand++;
508 :     last_cand = 3;
509 :     pmv[3] = mbs[rpos].mvs[rz];
510 :     } else pmv[3] = zeroMV;
511 :    
512 :     /* If there're more than one candidate, we return the median vector */
513 :    
514 :     if (num_cand > 1) {
515 :     /* set median */
516 :     pmv[0].x =
517 :     MIN(MAX(pmv[1].x, pmv[2].x),
518 :     MIN(MAX(pmv[2].x, pmv[3].x), MAX(pmv[1].x, pmv[3].x)));
519 :     pmv[0].y =
520 :     MIN(MAX(pmv[1].y, pmv[2].y),
521 :     MIN(MAX(pmv[2].y, pmv[3].y), MAX(pmv[1].y, pmv[3].y)));
522 :     return pmv[0];
523 :     }
524 :    
525 :     return pmv[last_cand]; /* no point calculating median mv */
526 : Isibaar 3 }
527 : edgomez 1382
528 : suxen_drol 1632 VECTOR get_pmv2_interlaced(const MACROBLOCK * const mbs,
529 :     const int mb_width,
530 :     const int bound,
531 :     const int x,
532 :     const int y,
533 :     const int block)
534 :     {
535 :     int lx, ly, lz; /* left */
536 :     int tx, ty, tz; /* top */
537 :     int rx, ry, rz; /* top-right */
538 :     int lpos, tpos, rpos;
539 :     int num_cand = 0, last_cand = 1;
540 :    
541 :     VECTOR pmv[4]; /* left neighbour, top neighbour, top-right neighbour */
542 :    
543 :     lx=x-1; ly=y; lz=1;
544 :     tx=x; ty=y-1; tz=2;
545 :     rx=x+1; ry=y-1; rz=2;
546 :    
547 :     lpos=lx+ly*mb_width;
548 :     rpos=rx+ry*mb_width;
549 :     tpos=tx+ty*mb_width;
550 :    
551 :     if(lx>=0 && lpos>=bound)
552 :     {
553 :     num_cand++;
554 :     if(mbs[lpos].field_pred)
555 :     pmv[1] = mbs[lpos].mvs_avg;
556 :     else
557 :     pmv[1] = mbs[lpos].mvs[lz];
558 :     }
559 :     else
560 :     {
561 :     pmv[1] = zeroMV;
562 :     }
563 :    
564 :     if(tpos>=bound)
565 :     {
566 :     num_cand++;
567 :     last_cand=2;
568 :     if(mbs[tpos].field_pred)
569 :     pmv[2] = mbs[tpos].mvs_avg;
570 :     else
571 :     pmv[2] = mbs[tpos].mvs[tz];
572 :     }
573 :     else
574 :     {
575 :     pmv[2] = zeroMV;
576 :     }
577 :    
578 :     if(rx<mb_width && rpos>=bound)
579 :     {
580 :     num_cand++;
581 :     last_cand = 3;
582 :     if(mbs[rpos].field_pred)
583 :     pmv[3] = mbs[rpos].mvs_avg;
584 :     else
585 :     pmv[3] = mbs[rpos].mvs[rz];
586 :     }
587 :     else
588 :     {
589 :     pmv[3] = zeroMV;
590 :     }
591 :    
592 :     /* If there're more than one candidate, we return the median vector */
593 :     if(num_cand>1)
594 :     {
595 :     /* set median */
596 :     pmv[0].x = MIN(MAX(pmv[1].x, pmv[2].x),
597 :     MIN(MAX(pmv[2].x, pmv[3].x), MAX(pmv[1].x, pmv[3].x)));
598 :     pmv[0].y = MIN(MAX(pmv[1].y, pmv[2].y),
599 :     MIN(MAX(pmv[2].y, pmv[3].y), MAX(pmv[1].y, pmv[3].y)));
600 :    
601 :     return pmv[0];
602 :     }
603 :    
604 :     return pmv[last_cand]; /* no point calculating median mv */
605 :     }
606 :    
607 : edgomez 1382 VECTOR
608 :     get_qpmv2(const MACROBLOCK * const mbs,
609 :     const int mb_width,
610 :     const int bound,
611 :     const int x,
612 :     const int y,
613 :     const int block)
614 :     {
615 :     int lx, ly, lz; /* left */
616 :     int tx, ty, tz; /* top */
617 :     int rx, ry, rz; /* top-right */
618 :     int lpos, tpos, rpos;
619 :     int num_cand = 0, last_cand = 1;
620 :    
621 :     VECTOR pmv[4]; /* left neighbour, top neighbour, top-right neighbour */
622 :    
623 :     switch (block) {
624 :     case 0:
625 :     lx = x - 1; ly = y; lz = 1;
626 :     tx = x; ty = y - 1; tz = 2;
627 :     rx = x + 1; ry = y - 1; rz = 2;
628 :     break;
629 :     case 1:
630 :     lx = x; ly = y; lz = 0;
631 :     tx = x; ty = y - 1; tz = 3;
632 :     rx = x + 1; ry = y - 1; rz = 2;
633 :     break;
634 :     case 2:
635 :     lx = x - 1; ly = y; lz = 3;
636 :     tx = x; ty = y; tz = 0;
637 :     rx = x; ry = y; rz = 1;
638 :     break;
639 :     default:
640 :     lx = x; ly = y; lz = 2;
641 :     tx = x; ty = y; tz = 0;
642 :     rx = x; ry = y; rz = 1;
643 :     }
644 :    
645 :     lpos = lx + ly * mb_width;
646 :     rpos = rx + ry * mb_width;
647 :     tpos = tx + ty * mb_width;
648 :    
649 :     if (lpos >= bound && lx >= 0) {
650 :     num_cand++;
651 :     pmv[1] = mbs[lpos].qmvs[lz];
652 :     } else pmv[1] = zeroMV;
653 :    
654 :     if (tpos >= bound) {
655 :     num_cand++;
656 :     last_cand = 2;
657 :     pmv[2] = mbs[tpos].qmvs[tz];
658 :     } else pmv[2] = zeroMV;
659 :    
660 :     if (rpos >= bound && rx < mb_width) {
661 :     num_cand++;
662 :     last_cand = 3;
663 :     pmv[3] = mbs[rpos].qmvs[rz];
664 :     } else pmv[3] = zeroMV;
665 :    
666 :     /* If there're more than one candidate, we return the median vector */
667 :    
668 :     if (num_cand > 1) {
669 :     /* set median */
670 :     pmv[0].x =
671 :     MIN(MAX(pmv[1].x, pmv[2].x),
672 :     MIN(MAX(pmv[2].x, pmv[3].x), MAX(pmv[1].x, pmv[3].x)));
673 :     pmv[0].y =
674 :     MIN(MAX(pmv[1].y, pmv[2].y),
675 :     MIN(MAX(pmv[2].y, pmv[3].y), MAX(pmv[1].y, pmv[3].y)));
676 :     return pmv[0];
677 :     }
678 :    
679 :     return pmv[last_cand]; /* no point calculating median mv */
680 :     }

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