1 /*!
2 *************************************************************************************
3 * \file mb_prediction.c
4 *
5 * \brief
6 * Macroblock prediction functions
7 *
8 * \author
9 * Main contributors (see contributors.h for copyright, address and affiliation details)
10 * - Alexis Michael Tourapis <alexismt@ieee.org>
11 *************************************************************************************
12 */
13
14 #include "contributors.h"
15
16 #include "block.h"
17 #include "global.h"
18 #include "mbuffer.h"
19 #include "elements.h"
20 #include "errorconcealment.h"
21 #include "macroblock.h"
22 #include "fmo.h"
23 #include "cabac.h"
24 #include "vlc.h"
25 #include "image.h"
26 #include "mb_access.h"
27 #include "biaridecod.h"
28 #include "transform8x8.h"
29 #include "transform.h"
30 #include "mc_prediction.h"
31 #include "quant.h"
32 #include "intra4x4_pred.h"
33 #include "intra8x8_pred.h"
34 #include "intra16x16_pred.h"
35 #include "mv_prediction.h"
36 #include "mb_prediction.h"
37
38 extern int get_colocated_info_8x8 (Macroblock *currMB, StorablePicture *list1, int i, int j);
39 extern int get_colocated_info_4x4 (Macroblock *currMB, StorablePicture *list1, int i, int j);
40
41
mb_pred_intra4x4(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)42 int mb_pred_intra4x4(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
43 {
44 Slice *currSlice = currMB->p_Slice;
45 int yuv = dec_picture->chroma_format_idc - 1;
46 int i=0, j=0,k, j4=0,i4=0;
47 int j_pos, i_pos;
48 int ioff,joff;
49 int block8x8; // needed for ABT
50 currMB->itrans_4x4 = (currMB->is_lossless == FALSE) ? itrans4x4 : Inv_Residual_trans_4x4;
51
52 for (block8x8 = 0; block8x8 < 4; block8x8++)
53 {
54 for (k = block8x8 * 4; k < block8x8 * 4 + 4; k ++)
55 {
56 i = (decode_block_scan[k] & 3);
57 j = ((decode_block_scan[k] >> 2) & 3);
58
59 ioff = (i << 2);
60 joff = (j << 2);
61 i4 = currMB->block_x + i;
62 j4 = currMB->block_y + j;
63 j_pos = j4 * BLOCK_SIZE;
64 i_pos = i4 * BLOCK_SIZE;
65
66 // PREDICTION
67 //===== INTRA PREDICTION =====
68 if (currSlice->intra_pred_4x4(currMB, curr_plane, ioff,joff,i4,j4) == SEARCH_SYNC) /* make 4x4 prediction block mpr from given prediction p_Vid->mb_mode */
69 return SEARCH_SYNC; /* bit error */
70 // =============== 4x4 itrans ================
71 // -------------------------------------------
72 currMB->itrans_4x4 (currMB, curr_plane, ioff, joff);
73
74 copy_image_data_4x4(&currImg[j_pos], &currSlice->mb_rec[curr_plane][joff], i_pos, ioff);
75 }
76 }
77
78 // chroma decoding *******************************************************
79 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
80 {
81 intra_cr_decoding(currMB, yuv);
82 }
83
84 if (currMB->cbp != 0)
85 currSlice->is_reset_coeff = FALSE;
86 return 1;
87 }
88
89
mb_pred_intra16x16(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)90 int mb_pred_intra16x16(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
91 {
92 int yuv = dec_picture->chroma_format_idc - 1;
93
94 currMB->p_Slice->intra_pred_16x16(currMB, curr_plane, currMB->i16mode);
95 currMB->ipmode_DPCM = (char) currMB->i16mode; //For residual DPCM
96 // =============== 4x4 itrans ================
97 // -------------------------------------------
98 iMBtrans4x4(currMB, curr_plane, 0);
99
100 // chroma decoding *******************************************************
101 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
102 {
103 intra_cr_decoding(currMB, yuv);
104 }
105
106 currMB->p_Slice->is_reset_coeff = FALSE;
107 return 1;
108 }
109
mb_pred_intra8x8(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)110 int mb_pred_intra8x8(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
111 {
112 Slice *currSlice = currMB->p_Slice;
113 int yuv = dec_picture->chroma_format_idc - 1;
114
115 int block8x8; // needed for ABT
116 currMB->itrans_8x8 = (currMB->is_lossless == FALSE) ? itrans8x8 : Inv_Residual_trans_8x8;
117
118 for (block8x8 = 0; block8x8 < 4; block8x8++)
119 {
120 //=========== 8x8 BLOCK TYPE ============
121 int ioff = (block8x8 & 0x01) << 3;
122 int joff = (block8x8 >> 1 ) << 3;
123
124 //PREDICTION
125 currSlice->intra_pred_8x8(currMB, curr_plane, ioff, joff);
126 if (currMB->cbp & (1 << block8x8))
127 currMB->itrans_8x8 (currMB, curr_plane, ioff,joff); // use inverse integer transform and make 8x8 block m7 from prediction block mpr
128 else
129 icopy8x8(currMB, curr_plane, ioff,joff);
130
131 copy_image_data_8x8(&currImg[currMB->pix_y + joff], &currSlice->mb_rec[curr_plane][joff], currMB->pix_x + ioff, ioff);
132 }
133 // chroma decoding *******************************************************
134 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
135 {
136 intra_cr_decoding(currMB, yuv);
137 }
138
139 if (currMB->cbp != 0)
140 currSlice->is_reset_coeff = FALSE;
141 return 1;
142 }
143
144
set_chroma_vector(Macroblock * currMB)145 static void set_chroma_vector(Macroblock *currMB)
146 {
147 Slice *currSlice = currMB->p_Slice;
148 VideoParameters *p_Vid = currMB->p_Vid;
149
150 if (!currSlice->mb_aff_frame_flag)
151 {
152 if(currSlice->structure == TOP_FIELD)
153 {
154 int k,l;
155 for (l = LIST_0; l <= (LIST_1); l++)
156 {
157 for(k = 0; k < currSlice->listXsize[l]; k++)
158 {
159 if(currSlice->structure != currSlice->listX[l][k]->structure)
160 currSlice->chroma_vector_adjustment[l][k] = -2;
161 else
162 currSlice->chroma_vector_adjustment[l][k] = 0;
163 }
164 }
165 }
166 else if(currSlice->structure == BOTTOM_FIELD)
167 {
168 int k,l;
169 for (l = LIST_0; l <= (LIST_1); l++)
170 {
171 for(k = 0; k < currSlice->listXsize[l]; k++)
172 {
173 if (currSlice->structure != currSlice->listX[l][k]->structure)
174 currSlice->chroma_vector_adjustment[l][k] = 2;
175 else
176 currSlice->chroma_vector_adjustment[l][k] = 0;
177 }
178 }
179 }
180 else
181 {
182 int k,l;
183 for (l = LIST_0; l <= (LIST_1); l++)
184 {
185 for(k = 0; k < currSlice->listXsize[l]; k++)
186 {
187 currSlice->chroma_vector_adjustment[l][k] = 0;
188 }
189 }
190 }
191 }
192 else
193 {
194 int mb_nr = (currMB->mbAddrX & 0x01);
195 int k,l;
196
197 //////////////////////////
198 // find out the correct list offsets
199 if (currMB->mb_field)
200 {
201 int list_offset = currMB->list_offset;
202
203 for (l = LIST_0 + list_offset; l <= (LIST_1 + list_offset); l++)
204 {
205 for(k = 0; k < currSlice->listXsize[l]; k++)
206 {
207 if(mb_nr == 0 && currSlice->listX[l][k]->structure == BOTTOM_FIELD)
208 currSlice->chroma_vector_adjustment[l][k] = -2;
209 else if(mb_nr == 1 && currSlice->listX[l][k]->structure == TOP_FIELD)
210 currSlice->chroma_vector_adjustment[l][k] = 2;
211 else
212 currSlice->chroma_vector_adjustment[l][k] = 0;
213 }
214 }
215 }
216 else
217 {
218 for (l = LIST_0; l <= (LIST_1); l++)
219 {
220 for(k = 0; k < currSlice->listXsize[l]; k++)
221 {
222 currSlice->chroma_vector_adjustment[l][k] = 0;
223 }
224 }
225 }
226 }
227
228 currSlice->max_mb_vmv_r = (currSlice->structure != FRAME || ( currMB->mb_field )) ? p_Vid->max_vmv_r >> 1 : p_Vid->max_vmv_r;
229 }
230
mb_pred_skip(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)231 int mb_pred_skip(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
232 {
233 Slice *currSlice = currMB->p_Slice;
234 VideoParameters *p_Vid = currMB->p_Vid;
235
236 set_chroma_vector(currMB);
237
238 perform_mc(currMB, curr_plane, dec_picture, LIST_0, 0, 0, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
239
240 copy_image_data_16x16(&currImg[currMB->pix_y], currSlice->mb_pred[curr_plane], currMB->pix_x, 0);
241
242 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
243 {
244
245 copy_image_data(&dec_picture->imgUV[0][currMB->pix_c_y], currSlice->mb_pred[1], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
246 copy_image_data(&dec_picture->imgUV[1][currMB->pix_c_y], currSlice->mb_pred[2], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
247 }
248 return 1;
249 }
250
mb_pred_sp_skip(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)251 int mb_pred_sp_skip(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
252 {
253 set_chroma_vector(currMB);
254
255 perform_mc(currMB, curr_plane, dec_picture, LIST_0, 0, 0, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
256 iTransform(currMB, curr_plane, 1);
257 return 1;
258 }
259
mb_pred_p_inter8x8(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)260 int mb_pred_p_inter8x8(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
261 {
262 int block8x8; // needed for ABT
263 int i=0, j=0,k;
264
265 Slice *currSlice = currMB->p_Slice;
266 int smb = currSlice->slice_type == SP_SLICE && (currMB->is_intra_block == FALSE);
267
268 set_chroma_vector(currMB);
269
270 for (block8x8=0; block8x8<4; block8x8++)
271 {
272 int mv_mode = currMB->b8mode[block8x8];
273 int pred_dir = currMB->b8pdir[block8x8];
274
275 int k_start = (block8x8 << 2);
276 int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
277 int k_end = (mv_mode == SMB8x8) ? k_start + 1 : ((mv_mode == SMB4x4) ? k_start + 4 : k_start + k_inc + 1);
278
279 int block_size_x = ( mv_mode == SMB8x4 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
280 int block_size_y = ( mv_mode == SMB4x8 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
281
282 for (k = k_start; k < k_end; k += k_inc)
283 {
284 i = (decode_block_scan[k] & 3);
285 j = ((decode_block_scan[k] >> 2) & 3);
286 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, block_size_x, block_size_y);
287 }
288 }
289
290 iTransform(currMB, curr_plane, smb);
291
292 if (currMB->cbp != 0)
293 currSlice->is_reset_coeff = FALSE;
294 return 1;
295 }
296
mb_pred_p_inter16x16(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)297 int mb_pred_p_inter16x16(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
298 {
299 Slice *currSlice = currMB->p_Slice;
300 int smb = (currSlice->slice_type == SP_SLICE);
301
302 set_chroma_vector(currMB);
303 perform_mc(currMB, curr_plane, dec_picture, currMB->b8pdir[0], 0, 0, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
304 iTransform(currMB, curr_plane, smb);
305
306 if (currMB->cbp != 0)
307 currSlice->is_reset_coeff = FALSE;
308 return 1;
309 }
310
mb_pred_p_inter16x8(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)311 int mb_pred_p_inter16x8(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
312 {
313 Slice *currSlice = currMB->p_Slice;
314 int smb = (currSlice->slice_type == SP_SLICE);
315
316 set_chroma_vector(currMB);
317
318 perform_mc(currMB, curr_plane, dec_picture, currMB->b8pdir[0], 0, 0, MB_BLOCK_SIZE, BLOCK_SIZE_8x8);
319 perform_mc(currMB, curr_plane, dec_picture, currMB->b8pdir[2], 0, 2, MB_BLOCK_SIZE, BLOCK_SIZE_8x8);
320 iTransform(currMB, curr_plane, smb);
321
322 if (currMB->cbp != 0)
323 currSlice->is_reset_coeff = FALSE;
324 return 1;
325 }
326
mb_pred_p_inter8x16(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)327 int mb_pred_p_inter8x16(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
328 {
329 Slice *currSlice = currMB->p_Slice;
330 int smb = (currSlice->slice_type == SP_SLICE);
331
332 set_chroma_vector(currMB);
333
334 perform_mc(currMB, curr_plane, dec_picture, currMB->b8pdir[0], 0, 0, BLOCK_SIZE_8x8, MB_BLOCK_SIZE);
335 perform_mc(currMB, curr_plane, dec_picture, currMB->b8pdir[1], 2, 0, BLOCK_SIZE_8x8, MB_BLOCK_SIZE);
336 iTransform(currMB, curr_plane, smb);
337
338 if (currMB->cbp != 0)
339 currSlice->is_reset_coeff = FALSE;
340 return 1;
341 }
342
update_neighbor_mvs(PicMotionParams ** motion,const PicMotionParams * mv_info,int i4)343 static inline void update_neighbor_mvs(PicMotionParams **motion, const PicMotionParams *mv_info, int i4)
344 {
345 (*motion++)[i4 + 1] = *mv_info;
346 (*motion )[i4 ] = *mv_info;
347 (*motion )[i4 + 1] = *mv_info;
348 }
349
mb_pred_b_d8x8temporal(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)350 int mb_pred_b_d8x8temporal(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
351 {
352 short ref_idx;
353 int refList;
354
355 int k, i, j, i4, j4, j6;
356 int block8x8; // needed for ABT
357 Slice *currSlice = currMB->p_Slice;
358 VideoParameters *p_Vid = currMB->p_Vid;
359 PicMotionParams *mv_info = NULL, *colocated = NULL;
360
361 int list_offset = currMB->list_offset;
362 StorablePicture **list0 = currSlice->listX[LIST_0 + list_offset];
363 StorablePicture **list1 = currSlice->listX[LIST_1 + list_offset];
364
365 set_chroma_vector(currMB);
366
367 //printf("currMB %d\n", currMB->mbAddrX);
368 for (block8x8=0; block8x8<4; block8x8++)
369 {
370 int pred_dir = currMB->b8pdir[block8x8];
371
372 int k_start = (block8x8 << 2);
373 int k_end = k_start + 1;
374
375 for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
376 {
377
378 i = (decode_block_scan[k] & 3);
379 j = ((decode_block_scan[k] >> 2) & 3);
380 i4 = currMB->block_x + i;
381 j4 = currMB->block_y + j;
382 j6 = currMB->block_y_aff + j;
383 mv_info = &dec_picture->mv_info[j4][i4];
384 colocated = &list1[0]->mv_info[RSD(j6)][RSD(i4)];
385 if(currMB->p_Vid->separate_colour_plane_flag && currMB->p_Vid->yuv_format==YUV444)
386 colocated = &list1[0]->JVmv_info[currMB->p_Slice->colour_plane_id][RSD(j6)][RSD(i4)];
387 if(currSlice->mb_aff_frame_flag /*&& (!p_Vid->active_sps->frame_mbs_only_flag || p_Vid->active_sps->direct_8x8_inference_flag)*/)
388 {
389 assert(p_Vid->active_sps->direct_8x8_inference_flag);
390 if(!currMB->mb_field && ((currSlice->listX[LIST_1][0]->iCodingType==FRAME_MB_PAIR_CODING && currSlice->listX[LIST_1][0]->motion.mb_field[currMB->mbAddrX]) ||
391 (currSlice->listX[LIST_1][0]->iCodingType==FIELD_CODING)))
392 {
393 if (iabs(dec_picture->poc - currSlice->listX[LIST_1+4][0]->poc)> iabs(dec_picture->poc -currSlice->listX[LIST_1+2][0]->poc) )
394 {
395 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
396 &currSlice->listX[LIST_1+2][0]->mv_info[RSD(j6)>>1][RSD(i4)] : &currSlice->listX[LIST_1+2][0]->mv_info[j6>>1][i4];
397 }
398 else
399 {
400 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
401 &currSlice->listX[LIST_1+4][0]->mv_info[RSD(j6)>>1][RSD(i4)] : &currSlice->listX[LIST_1+4][0]->mv_info[j6>>1][i4];
402 }
403 }
404 }
405 else if(/*!currSlice->mb_aff_frame_flag &&*/ !p_Vid->active_sps->frame_mbs_only_flag &&
406 (!currSlice->field_pic_flag && currSlice->listX[LIST_1][0]->iCodingType!=FRAME_CODING))
407 {
408 if (iabs(dec_picture->poc - list1[0]->bottom_field->poc)> iabs(dec_picture->poc -list1[0]->top_field->poc) )
409 {
410 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
411 &list1[0]->top_field->mv_info[RSD(j6)>>1][RSD(i4)] : &list1[0]->top_field->mv_info[j6>>1][i4];
412 }
413 else
414 {
415 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
416 &list1[0]->bottom_field->mv_info[RSD(j6)>>1][RSD(i4)] : &list1[0]->bottom_field->mv_info[j6>>1][i4];
417 }
418 }
419 else if(!p_Vid->active_sps->frame_mbs_only_flag && currSlice->field_pic_flag && currSlice->structure!=list1[0]->structure && list1[0]->coded_frame)
420 {
421 if (currSlice->structure == TOP_FIELD)
422 {
423 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
424 &list1[0]->frame->top_field->mv_info[RSD(j6)][RSD(i4)] : &list1[0]->frame->top_field->mv_info[j6][i4];
425 }
426 else
427 {
428 colocated = p_Vid->active_sps->direct_8x8_inference_flag ?
429 &list1[0]->frame->bottom_field->mv_info[RSD(j6)][RSD(i4)] : &list1[0]->frame->bottom_field->mv_info[j6][i4];
430 }
431 }
432
433
434 assert (pred_dir<=2);
435
436 refList = (colocated->ref_idx[LIST_0]== -1 ? LIST_1 : LIST_0);
437 ref_idx = colocated->ref_idx[refList];
438
439 if(ref_idx==-1) // co-located is intra mode
440 {
441 mv_info->mv[LIST_0] = zero_mv;
442 mv_info->mv[LIST_1] = zero_mv;
443
444 mv_info->ref_idx[LIST_0] = 0;
445 mv_info->ref_idx[LIST_1] = 0;
446 }
447 else // co-located skip or inter mode
448 {
449 int mapped_idx=0;
450 int iref;
451 if( (currSlice->mb_aff_frame_flag && ( (currMB->mb_field && colocated->ref_pic[refList]->structure==FRAME) ||
452 (!currMB->mb_field && colocated->ref_pic[refList]->structure!=FRAME))) ||
453 (!currSlice->mb_aff_frame_flag && ((currSlice->field_pic_flag==0 && colocated->ref_pic[refList]->structure!=FRAME)
454 ||(currSlice->field_pic_flag==1 && colocated->ref_pic[refList]->structure==FRAME))) )
455 {
456 for (iref = 0; iref < imin(currSlice->num_ref_idx_active[LIST_0], currSlice->listXsize[LIST_0 + list_offset]);iref++)
457 {
458 if(currSlice->listX[LIST_0 + list_offset][iref]->top_field == colocated->ref_pic[refList] ||
459 currSlice->listX[LIST_0 + list_offset][iref]->bottom_field == colocated->ref_pic[refList] ||
460 currSlice->listX[LIST_0 + list_offset][iref]->frame == colocated->ref_pic[refList])
461 {
462 if ((currSlice->field_pic_flag==1) && (currSlice->listX[LIST_0 + list_offset][iref]->structure != currSlice->structure))
463 {
464 mapped_idx=INVALIDINDEX;
465 }
466 else
467 {
468 mapped_idx = iref;
469 break;
470 }
471 }
472 else //! invalid index. Default to zero even though this case should not happen
473 {
474 mapped_idx=INVALIDINDEX;
475 }
476 }
477 }
478 else
479 {
480 for (iref = 0; iref < imin(currSlice->num_ref_idx_active[LIST_0], currSlice->listXsize[LIST_0 + list_offset]);iref++)
481 {
482 if(currSlice->listX[LIST_0 + list_offset][iref] == colocated->ref_pic[refList])
483 {
484 mapped_idx = iref;
485 break;
486 }
487 else //! invalid index. Default to zero even though this case should not happen
488 {
489 mapped_idx=INVALIDINDEX;
490 }
491 }
492 }
493
494 if(INVALIDINDEX != mapped_idx)
495 {
496 int mv_scale = currSlice->mvscale[LIST_0 + list_offset][mapped_idx];
497 int mv_y = colocated->mv[refList].mv_y;
498 if((currSlice->mb_aff_frame_flag && !currMB->mb_field && colocated->ref_pic[refList]->structure!=FRAME) ||
499 (!currSlice->mb_aff_frame_flag && currSlice->field_pic_flag==0 && colocated->ref_pic[refList]->structure!=FRAME) )
500 mv_y *= 2;
501 else if((currSlice->mb_aff_frame_flag && currMB->mb_field && colocated->ref_pic[refList]->structure==FRAME) ||
502 (!currSlice->mb_aff_frame_flag && currSlice->field_pic_flag==1 && colocated->ref_pic[refList]->structure==FRAME) )
503 mv_y /= 2;
504
505 //! In such case, an array is needed for each different reference.
506 if (mv_scale == 9999 || currSlice->listX[LIST_0 + list_offset][mapped_idx]->is_long_term)
507 {
508 mv_info->mv[LIST_0].mv_x = colocated->mv[refList].mv_x;
509 mv_info->mv[LIST_0].mv_y = (short) mv_y;
510 mv_info->mv[LIST_1] = zero_mv;
511 }
512 else
513 {
514 mv_info->mv[LIST_0].mv_x = (short) ((mv_scale * colocated->mv[refList].mv_x + 128 ) >> 8);
515 mv_info->mv[LIST_0].mv_y = (short) ((mv_scale * mv_y/*colocated->mv[refList].mv_y*/ + 128 ) >> 8);
516
517 mv_info->mv[LIST_1].mv_x = (short) (mv_info->mv[LIST_0].mv_x - colocated->mv[refList].mv_x);
518 mv_info->mv[LIST_1].mv_y = (short) (mv_info->mv[LIST_0].mv_y - mv_y/*colocated->mv[refList].mv_y*/);
519 }
520
521 mv_info->ref_idx[LIST_0] = (char) mapped_idx; //colocated->ref_idx[refList];
522 mv_info->ref_idx[LIST_1] = 0;
523 }
524 else if (INVALIDINDEX == mapped_idx)
525 {
526 error("temporal direct error: colocated block has ref that is unavailable",-1111);
527 }
528
529 }
530 // store reference picture ID determined by direct mode
531 mv_info->ref_pic[LIST_0] = list0[(short)mv_info->ref_idx[LIST_0]];
532 mv_info->ref_pic[LIST_1] = list1[(short)mv_info->ref_idx[LIST_1]];
533 }
534
535 for (k = k_start; k < k_end; k ++)
536 {
537 int i = (decode_block_scan[k] & 3);
538 int j = ((decode_block_scan[k] >> 2) & 3);
539 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, SMB_BLOCK_SIZE, SMB_BLOCK_SIZE);
540 }
541 }
542
543 if (currMB->cbp == 0)
544 {
545 copy_image_data_16x16(&currImg[currMB->pix_y], currSlice->mb_pred[curr_plane], currMB->pix_x, 0);
546
547 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
548 {
549 copy_image_data(&dec_picture->imgUV[0][currMB->pix_c_y], currSlice->mb_pred[1], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
550 copy_image_data(&dec_picture->imgUV[1][currMB->pix_c_y], currSlice->mb_pred[2], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
551 }
552 }
553 else
554 {
555 iTransform(currMB, curr_plane, 0);
556 currSlice->is_reset_coeff = FALSE;
557 }
558 return 1;
559 }
560
mb_pred_b_d4x4temporal(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)561 int mb_pred_b_d4x4temporal(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
562 {
563 short ref_idx;
564 int refList;
565
566 int k;
567 int block8x8; // needed for ABT
568 Slice *currSlice = currMB->p_Slice;
569 VideoParameters *p_Vid = currMB->p_Vid;
570
571 int list_offset = currMB->list_offset;
572 StorablePicture **list0 = currSlice->listX[LIST_0 + list_offset];
573 StorablePicture **list1 = currSlice->listX[LIST_1 + list_offset];
574
575 set_chroma_vector(currMB);
576
577 for (block8x8=0; block8x8<4; block8x8++)
578 {
579 int pred_dir = currMB->b8pdir[block8x8];
580
581 int k_start = (block8x8 << 2);
582 int k_end = k_start + BLOCK_MULTIPLE;
583
584 for (k = k_start; k < k_end; k ++)
585 {
586
587 int i = (decode_block_scan[k] & 3);
588 int j = ((decode_block_scan[k] >> 2) & 3);
589 int i4 = currMB->block_x + i;
590 int j4 = currMB->block_y + j;
591 int j6 = currMB->block_y_aff + j;
592 PicMotionParams *mv_info = &dec_picture->mv_info[j4][i4];
593 PicMotionParams *colocated = &list1[0]->mv_info[j6][i4];
594 if(currMB->p_Vid->separate_colour_plane_flag && currMB->p_Vid->yuv_format==YUV444)
595 colocated = &list1[0]->JVmv_info[currMB->p_Slice->colour_plane_id][RSD(j6)][RSD(i4)];
596 assert (pred_dir<=2);
597
598 refList = (colocated->ref_idx[LIST_0]== -1 ? LIST_1 : LIST_0);
599 ref_idx = colocated->ref_idx[refList];
600
601 if(ref_idx==-1) // co-located is intra mode
602 {
603 mv_info->mv[LIST_0] = zero_mv;
604 mv_info->mv[LIST_1] = zero_mv;
605
606 mv_info->ref_idx[LIST_0] = 0;
607 mv_info->ref_idx[LIST_1] = 0;
608 }
609 else // co-located skip or inter mode
610 {
611 int mapped_idx=0;
612 int iref;
613
614 for (iref=0;iref<imin(currSlice->num_ref_idx_active[LIST_0], currSlice->listXsize[LIST_0 + list_offset]);iref++)
615 {
616 if(currSlice->listX[LIST_0 + list_offset][iref] == colocated->ref_pic[refList])
617 {
618 mapped_idx=iref;
619 break;
620 }
621 else //! invalid index. Default to zero even though this case should not happen
622 {
623 mapped_idx=INVALIDINDEX;
624 }
625 }
626 if (INVALIDINDEX == mapped_idx)
627 {
628 error("temporal direct error: colocated block has ref that is unavailable",-1111);
629 }
630 else
631 {
632 int mv_scale = currSlice->mvscale[LIST_0 + list_offset][mapped_idx];
633
634 //! In such case, an array is needed for each different reference.
635 if (mv_scale == 9999 || currSlice->listX[LIST_0+list_offset][mapped_idx]->is_long_term)
636 {
637 mv_info->mv[LIST_0] = colocated->mv[refList];
638 mv_info->mv[LIST_1] = zero_mv;
639 }
640 else
641 {
642 mv_info->mv[LIST_0].mv_x = (short) ((mv_scale * colocated->mv[refList].mv_x + 128 ) >> 8);
643 mv_info->mv[LIST_0].mv_y = (short) ((mv_scale * colocated->mv[refList].mv_y + 128 ) >> 8);
644
645 mv_info->mv[LIST_1].mv_x = (short) (mv_info->mv[LIST_0].mv_x - colocated->mv[refList].mv_x);
646 mv_info->mv[LIST_1].mv_y = (short) (mv_info->mv[LIST_0].mv_y - colocated->mv[refList].mv_y);
647 }
648
649 mv_info->ref_idx[LIST_0] = (char) mapped_idx; //colocated->ref_idx[refList];
650 mv_info->ref_idx[LIST_1] = 0;
651 }
652 }
653 // store reference picture ID determined by direct mode
654 mv_info->ref_pic[LIST_0] = list0[(short)mv_info->ref_idx[LIST_0]];
655 mv_info->ref_pic[LIST_1] = list1[(short)mv_info->ref_idx[LIST_1]];
656 }
657
658 for (k = k_start; k < k_end; k ++)
659 {
660 int i = (decode_block_scan[k] & 3);
661 int j = ((decode_block_scan[k] >> 2) & 3);
662 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, BLOCK_SIZE, BLOCK_SIZE);
663
664 }
665 }
666
667 if (currMB->cbp == 0)
668 {
669 copy_image_data_16x16(&currImg[currMB->pix_y], currSlice->mb_pred[curr_plane], currMB->pix_x, 0);
670
671 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
672 {
673 copy_image_data(&dec_picture->imgUV[0][currMB->pix_c_y], currSlice->mb_pred[1], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
674 copy_image_data(&dec_picture->imgUV[1][currMB->pix_c_y], currSlice->mb_pred[2], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
675 }
676 }
677 else
678 {
679 iTransform(currMB, curr_plane, 0);
680 currSlice->is_reset_coeff = FALSE;
681 }
682
683 return 1;
684 }
685
686
mb_pred_b_d8x8spatial(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)687 int mb_pred_b_d8x8spatial(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
688 {
689 char l0_rFrame = -1, l1_rFrame = -1;
690 MotionVector pmvl0 = zero_mv, pmvl1 = zero_mv;
691 int i4, j4;
692 int block8x8;
693 Slice *currSlice = currMB->p_Slice;
694 VideoParameters *p_Vid = currMB->p_Vid;
695
696 PicMotionParams *mv_info;
697 int list_offset = currMB->list_offset;
698 StorablePicture **list0 = currSlice->listX[LIST_0 + list_offset];
699 StorablePicture **list1 = currSlice->listX[LIST_1 + list_offset];
700
701 int pred_dir = 0;
702
703 set_chroma_vector(currMB);
704
705 prepare_direct_params(currMB, dec_picture, &pmvl0, &pmvl1, &l0_rFrame, &l1_rFrame);
706
707 if (l0_rFrame == 0 || l1_rFrame == 0)
708 {
709 int is_not_moving;
710
711 for (block8x8 = 0; block8x8 < 4; block8x8++)
712 {
713 int k_start = (block8x8 << 2);
714
715 int i = (decode_block_scan[k_start] & 3);
716 int j = ((decode_block_scan[k_start] >> 2) & 3);
717 i4 = currMB->block_x + i;
718 j4 = currMB->block_y + j;
719
720 is_not_moving = (get_colocated_info_8x8(currMB, list1[0], i4, currMB->block_y_aff + j) == 0);
721
722 mv_info = &dec_picture->mv_info[j4][i4];
723
724 //===== DIRECT PREDICTION =====
725 if (l1_rFrame == -1)
726 {
727 if (is_not_moving)
728 {
729 mv_info->ref_pic[LIST_0] = list0[0];
730 mv_info->ref_pic[LIST_1] = NULL;
731 mv_info->mv[LIST_0] = zero_mv;
732 mv_info->mv[LIST_1] = zero_mv;
733 mv_info->ref_idx[LIST_0] = 0;
734 mv_info->ref_idx[LIST_1] = -1;
735 }
736 else
737 {
738 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
739 mv_info->ref_pic[LIST_1] = NULL;
740 mv_info->mv[LIST_0] = pmvl0;
741 mv_info->mv[LIST_1] = zero_mv;
742 mv_info->ref_idx[LIST_0] = l0_rFrame;
743 mv_info->ref_idx[LIST_1] = -1;
744 }
745 pred_dir = 0;
746 }
747 else if (l0_rFrame == -1)
748 {
749 if (is_not_moving)
750 {
751 mv_info->ref_pic[LIST_0] = NULL;
752 mv_info->ref_pic[LIST_1] = list1[0];
753 mv_info->mv[LIST_0] = zero_mv;
754 mv_info->mv[LIST_1] = zero_mv;
755 mv_info->ref_idx[LIST_0] = -1;
756 mv_info->ref_idx[LIST_1] = 0;
757 }
758 else
759 {
760 mv_info->ref_pic[LIST_0] = NULL;
761 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
762 mv_info->mv[LIST_0] = zero_mv;
763 mv_info->mv[LIST_1] = pmvl1;
764 mv_info->ref_idx[LIST_0] = -1;
765 mv_info->ref_idx[LIST_1] = l1_rFrame;
766 }
767 pred_dir = 1;
768 }
769 else
770 {
771 if (l0_rFrame == 0 && ((is_not_moving)))
772 {
773 mv_info->ref_pic[LIST_0] = list0[0];
774 mv_info->mv[LIST_0] = zero_mv;
775 mv_info->ref_idx[LIST_0] = 0;
776 }
777 else
778 {
779 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
780 mv_info->mv[LIST_0] = pmvl0;
781 mv_info->ref_idx[LIST_0] = l0_rFrame;
782 }
783
784 if (l1_rFrame == 0 && ((is_not_moving)))
785 {
786 mv_info->ref_pic[LIST_1] = list1[0];
787 mv_info->mv[LIST_1] = zero_mv;
788 mv_info->ref_idx[LIST_1] = 0;
789 }
790 else
791 {
792 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
793 mv_info->mv[LIST_1] = pmvl1;
794 mv_info->ref_idx[LIST_1] = l1_rFrame;
795 }
796 pred_dir = 2;
797 }
798
799 update_neighbor_mvs(&dec_picture->mv_info[j4], mv_info, i4);
800 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, SMB_BLOCK_SIZE, SMB_BLOCK_SIZE);
801 }
802 }
803 else
804 {
805 //===== DIRECT PREDICTION =====
806 if (l0_rFrame < 0 && l1_rFrame < 0)
807 {
808 pred_dir = 2;
809 for (j4 = currMB->block_y; j4 < currMB->block_y + BLOCK_MULTIPLE; j4 += 2)
810 {
811 for (i4 = currMB->block_x; i4 < currMB->block_x + BLOCK_MULTIPLE; i4 += 2)
812 {
813 mv_info = &dec_picture->mv_info[j4][i4];
814
815 mv_info->ref_pic[LIST_0] = list0[0];
816 mv_info->ref_pic[LIST_1] = list1[0];
817 mv_info->mv[LIST_0] = zero_mv;
818 mv_info->mv[LIST_1] = zero_mv;
819 mv_info->ref_idx[LIST_0] = 0;
820 mv_info->ref_idx[LIST_1] = 0;
821
822 update_neighbor_mvs(&dec_picture->mv_info[j4], mv_info, i4);
823 }
824 }
825 }
826 else if (l1_rFrame == -1)
827 {
828 pred_dir = 0;
829
830 for (j4 = currMB->block_y; j4 < currMB->block_y + BLOCK_MULTIPLE; j4 += 2)
831 {
832 for (i4 = currMB->block_x; i4 < currMB->block_x + BLOCK_MULTIPLE; i4 += 2)
833 {
834 mv_info = &dec_picture->mv_info[j4][i4];
835
836 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
837 mv_info->ref_pic[LIST_1] = NULL;
838 mv_info->mv[LIST_0] = pmvl0;
839 mv_info->mv[LIST_1] = zero_mv;
840 mv_info->ref_idx[LIST_0] = l0_rFrame;
841 mv_info->ref_idx[LIST_1] = -1;
842
843 update_neighbor_mvs(&dec_picture->mv_info[j4], mv_info, i4);
844 }
845 }
846 }
847 else if (l0_rFrame == -1)
848 {
849 pred_dir = 1;
850 for (j4 = currMB->block_y; j4 < currMB->block_y + BLOCK_MULTIPLE; j4 += 2)
851 {
852 for (i4 = currMB->block_x; i4 < currMB->block_x + BLOCK_MULTIPLE; i4 += 2)
853 {
854 mv_info = &dec_picture->mv_info[j4][i4];
855
856 mv_info->ref_pic[LIST_0] = NULL;
857 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
858 mv_info->mv[LIST_0] = zero_mv;
859 mv_info->mv[LIST_1] = pmvl1;
860 mv_info->ref_idx[LIST_0] = -1;
861 mv_info->ref_idx[LIST_1] = l1_rFrame;
862
863 update_neighbor_mvs(&dec_picture->mv_info[j4], mv_info, i4);
864 }
865 }
866 }
867 else
868 {
869 pred_dir = 2;
870
871 for (j4 = currMB->block_y; j4 < currMB->block_y + BLOCK_MULTIPLE; j4 += 2)
872 {
873 for (i4 = currMB->block_x; i4 < currMB->block_x + BLOCK_MULTIPLE; i4 += 2)
874 {
875 mv_info = &dec_picture->mv_info[j4][i4];
876
877 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
878 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
879 mv_info->mv[LIST_0] = pmvl0;
880 mv_info->mv[LIST_1] = pmvl1;
881 mv_info->ref_idx[LIST_0] = l0_rFrame;
882 mv_info->ref_idx[LIST_1] = l1_rFrame;
883
884 update_neighbor_mvs(&dec_picture->mv_info[j4], mv_info, i4);
885 }
886 }
887 }
888 // Now perform Motion Compensation
889 perform_mc(currMB, curr_plane, dec_picture, pred_dir, 0, 0, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
890 }
891
892 if (currMB->cbp == 0)
893 {
894 copy_image_data_16x16(&currImg[currMB->pix_y], currSlice->mb_pred[curr_plane], currMB->pix_x, 0);
895
896 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
897 {
898 copy_image_data(&dec_picture->imgUV[0][currMB->pix_c_y], currSlice->mb_pred[1], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
899 copy_image_data(&dec_picture->imgUV[1][currMB->pix_c_y], currSlice->mb_pred[2], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
900 }
901 }
902 else
903 {
904 iTransform(currMB, curr_plane, 0);
905 currSlice->is_reset_coeff = FALSE;
906 }
907
908 return 1;
909 }
910
911
mb_pred_b_d4x4spatial(Macroblock * currMB,ColorPlane curr_plane,imgpel ** currImg,StorablePicture * dec_picture)912 int mb_pred_b_d4x4spatial(Macroblock *currMB, ColorPlane curr_plane, imgpel **currImg, StorablePicture *dec_picture)
913 {
914 char l0_rFrame = -1, l1_rFrame = -1;
915 MotionVector pmvl0 = zero_mv, pmvl1 = zero_mv;
916 int k;
917 int block8x8;
918 Slice *currSlice = currMB->p_Slice;
919 VideoParameters *p_Vid = currMB->p_Vid;
920
921 PicMotionParams *mv_info;
922 int list_offset = currMB->list_offset;
923 StorablePicture **list0 = currSlice->listX[LIST_0 + list_offset];
924 StorablePicture **list1 = currSlice->listX[LIST_1 + list_offset];
925
926 int pred_dir = 0;
927
928 set_chroma_vector(currMB);
929
930 prepare_direct_params(currMB, dec_picture, &pmvl0, &pmvl1, &l0_rFrame, &l1_rFrame);
931
932 for (block8x8 = 0; block8x8 < 4; block8x8++)
933 {
934 int k_start = (block8x8 << 2);
935 int k_end = k_start + BLOCK_MULTIPLE;
936
937 for (k = k_start; k < k_end; k ++)
938 {
939 int i = (decode_block_scan[k] & 3);
940 int j = ((decode_block_scan[k] >> 2) & 3);
941 int i4 = currMB->block_x + i;
942 int j4 = currMB->block_y + j;
943
944 mv_info = &dec_picture->mv_info[j4][i4];
945 //===== DIRECT PREDICTION =====
946 if (l0_rFrame == 0 || l1_rFrame == 0)
947 {
948 int is_not_moving = (get_colocated_info_4x4(currMB, list1[0], i4, currMB->block_y_aff + j) == 0);
949
950 if (l1_rFrame == -1)
951 {
952 if (is_not_moving)
953 {
954 mv_info->ref_pic[LIST_0] = list0[0];
955 mv_info->ref_pic[LIST_1] = NULL;
956 mv_info->mv[LIST_0] = zero_mv;
957 mv_info->mv[LIST_1] = zero_mv;
958 mv_info->ref_idx[LIST_0] = 0;
959 mv_info->ref_idx[LIST_1] = -1;
960 }
961 else
962 {
963 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
964 mv_info->ref_pic[LIST_1] = NULL;
965 mv_info->mv[LIST_0] = pmvl0;
966 mv_info->mv[LIST_1] = zero_mv;
967 mv_info->ref_idx[LIST_0] = l0_rFrame;
968 mv_info->ref_idx[LIST_1] = -1;
969 }
970 pred_dir = 0;
971 }
972 else if (l0_rFrame == -1)
973 {
974 if (is_not_moving)
975 {
976 mv_info->ref_pic[LIST_0] = NULL;
977 mv_info->ref_pic[LIST_1] = list1[0];
978 mv_info->mv[LIST_0] = zero_mv;
979 mv_info->mv[LIST_1] = zero_mv;
980 mv_info->ref_idx[LIST_0] = -1;
981 mv_info->ref_idx[LIST_1] = 0;
982 }
983 else
984 {
985 mv_info->ref_pic[LIST_0] = NULL;
986 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
987 mv_info->mv[LIST_0] = zero_mv;
988 mv_info->mv[LIST_1] = pmvl1;
989 mv_info->ref_idx[LIST_0] = -1;
990 mv_info->ref_idx[LIST_1] = l1_rFrame;
991 }
992 pred_dir = 1;
993 }
994 else
995 {
996 if (l0_rFrame == 0 && ((is_not_moving)))
997 {
998 mv_info->ref_pic[LIST_0] = list0[0];
999 mv_info->mv[LIST_0] = zero_mv;
1000 mv_info->ref_idx[LIST_0] = 0;
1001 }
1002 else
1003 {
1004 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
1005 mv_info->mv[LIST_0] = pmvl0;
1006 mv_info->ref_idx[LIST_0] = l0_rFrame;
1007 }
1008
1009 if (l1_rFrame == 0 && ((is_not_moving)))
1010 {
1011 mv_info->ref_pic[LIST_1] = list1[0];
1012 mv_info->mv[LIST_1] = zero_mv;
1013 mv_info->ref_idx[LIST_1] = 0;
1014 }
1015 else
1016 {
1017 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
1018 mv_info->mv[LIST_1] = pmvl1;
1019 mv_info->ref_idx[LIST_1] = l1_rFrame;
1020 }
1021 pred_dir = 2;
1022 }
1023 }
1024 else
1025 {
1026 mv_info = &dec_picture->mv_info[j4][i4];
1027
1028 if (l0_rFrame < 0 && l1_rFrame < 0)
1029 {
1030 pred_dir = 2;
1031 mv_info->ref_pic[LIST_0] = list0[0];
1032 mv_info->ref_pic[LIST_1] = list1[0];
1033 mv_info->mv[LIST_0] = zero_mv;
1034 mv_info->mv[LIST_1] = zero_mv;
1035 mv_info->ref_idx[LIST_0] = 0;
1036 mv_info->ref_idx[LIST_1] = 0;
1037 }
1038 else if (l1_rFrame == -1)
1039 {
1040 pred_dir = 0;
1041 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
1042 mv_info->ref_pic[LIST_1] = NULL;
1043 mv_info->mv[LIST_0] = pmvl0;
1044 mv_info->mv[LIST_1] = zero_mv;
1045 mv_info->ref_idx[LIST_0] = l0_rFrame;
1046 mv_info->ref_idx[LIST_1] = -1;
1047 }
1048 else if (l0_rFrame == -1)
1049 {
1050 pred_dir = 1;
1051 mv_info->ref_pic[LIST_0] = NULL;
1052 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
1053 mv_info->mv[LIST_0] = zero_mv;
1054 mv_info->mv[LIST_1] = pmvl1;
1055 mv_info->ref_idx[LIST_0] = -1;
1056 mv_info->ref_idx[LIST_1] = l1_rFrame;
1057 }
1058 else
1059 {
1060 pred_dir = 2;
1061 mv_info->ref_pic[LIST_0] = list0[(short) l0_rFrame];
1062 mv_info->ref_pic[LIST_1] = list1[(short) l1_rFrame];
1063 mv_info->mv[LIST_0] = pmvl0;
1064 mv_info->mv[LIST_1] = pmvl1;
1065 mv_info->ref_idx[LIST_0] = l0_rFrame;
1066 mv_info->ref_idx[LIST_1] = l1_rFrame;
1067 }
1068 }
1069 }
1070
1071 for (k = k_start; k < k_end; k ++)
1072 {
1073 int i = (decode_block_scan[k] & 3);
1074 int j = ((decode_block_scan[k] >> 2) & 3);
1075
1076 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, BLOCK_SIZE, BLOCK_SIZE);
1077 }
1078 }
1079
1080 if (currMB->cbp == 0)
1081 {
1082 copy_image_data_16x16(&currImg[currMB->pix_y], currSlice->mb_pred[curr_plane], currMB->pix_x, 0);
1083
1084 if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
1085 {
1086 copy_image_data(&dec_picture->imgUV[0][currMB->pix_c_y], currSlice->mb_pred[1], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
1087 copy_image_data(&dec_picture->imgUV[1][currMB->pix_c_y], currSlice->mb_pred[2], currMB->pix_c_x, 0, p_Vid->mb_size[1][0], p_Vid->mb_size[1][1]);
1088 }
1089 }
1090 else
1091 {
1092 iTransform(currMB, curr_plane, 0);
1093 currSlice->is_reset_coeff = FALSE;
1094 }
1095
1096 return 1;
1097 }
1098
mb_pred_b_inter8x8(Macroblock * currMB,ColorPlane curr_plane,StorablePicture * dec_picture)1099 int mb_pred_b_inter8x8(Macroblock *currMB, ColorPlane curr_plane, StorablePicture *dec_picture)
1100 {
1101 char l0_rFrame = -1, l1_rFrame = -1;
1102 MotionVector pmvl0 = zero_mv, pmvl1 = zero_mv;
1103 int block_size_x, block_size_y;
1104 int k;
1105 int block8x8; // needed for ABT
1106 Slice *currSlice = currMB->p_Slice;
1107 VideoParameters *p_Vid = currMB->p_Vid;
1108
1109 int list_offset = currMB->list_offset;
1110 StorablePicture **list0 = currSlice->listX[LIST_0 + list_offset];
1111 StorablePicture **list1 = currSlice->listX[LIST_1 + list_offset];
1112
1113 set_chroma_vector(currMB);
1114
1115 // prepare direct modes
1116 if (currSlice->direct_spatial_mv_pred_flag && (!(currMB->b8mode[0] && currMB->b8mode[1] && currMB->b8mode[2] && currMB->b8mode[3])))
1117 prepare_direct_params(currMB, dec_picture, &pmvl0, &pmvl1, &l0_rFrame, &l1_rFrame);
1118
1119 for (block8x8=0; block8x8<4; block8x8++)
1120 {
1121 int mv_mode = currMB->b8mode[block8x8];
1122 int pred_dir = currMB->b8pdir[block8x8];
1123
1124 if ( mv_mode != 0 )
1125 {
1126 int k_start = (block8x8 << 2);
1127 int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
1128 int k_end = (mv_mode == SMB8x8) ? k_start + 1 : ((mv_mode == SMB4x4) ? k_start + 4 : k_start + k_inc + 1);
1129
1130 block_size_x = ( mv_mode == SMB8x4 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
1131 block_size_y = ( mv_mode == SMB4x8 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
1132
1133 for (k = k_start; k < k_end; k += k_inc)
1134 {
1135 int i = (decode_block_scan[k] & 3);
1136 int j = ((decode_block_scan[k] >> 2) & 3);
1137 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, block_size_x, block_size_y);
1138 }
1139 }
1140 else
1141 {
1142 int k_start = (block8x8 << 2);
1143 int k_end = k_start;
1144
1145 if (p_Vid->active_sps->direct_8x8_inference_flag)
1146 {
1147 block_size_x = SMB_BLOCK_SIZE;
1148 block_size_y = SMB_BLOCK_SIZE;
1149 k_end ++;
1150 }
1151 else
1152 {
1153 block_size_x = BLOCK_SIZE;
1154 block_size_y = BLOCK_SIZE;
1155 k_end += BLOCK_MULTIPLE;
1156 }
1157
1158 // Prepare mvs (needed for deblocking and mv prediction
1159 if (currSlice->direct_spatial_mv_pred_flag)
1160 {
1161 for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
1162 {
1163 int i = (decode_block_scan[k] & 3);
1164 int j = ((decode_block_scan[k] >> 2) & 3);
1165 int i4 = currMB->block_x + i;
1166 int j4 = currMB->block_y + j;
1167 PicMotionParams *mv_info = &dec_picture->mv_info[j4][i4];
1168
1169 assert (pred_dir<=2);
1170
1171 //===== DIRECT PREDICTION =====
1172 // motion information should be already set
1173 if (mv_info->ref_idx[LIST_1] == -1)
1174 {
1175 pred_dir = 0;
1176 }
1177 else if (mv_info->ref_idx[LIST_0] == -1)
1178 {
1179 pred_dir = 1;
1180 }
1181 else
1182 {
1183 pred_dir = 2;
1184 }
1185 }
1186 }
1187 else
1188 {
1189 for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
1190 {
1191
1192 int i = (decode_block_scan[k] & 3);
1193 int j = ((decode_block_scan[k] >> 2) & 3);
1194 int i4 = currMB->block_x + i;
1195 int j4 = currMB->block_y + j;
1196 PicMotionParams *mv_info = &dec_picture->mv_info[j4][i4];
1197
1198 assert (pred_dir<=2);
1199
1200 // store reference picture ID determined by direct mode
1201 mv_info->ref_pic[LIST_0] = list0[(short)mv_info->ref_idx[LIST_0]];
1202 mv_info->ref_pic[LIST_1] = list1[(short)mv_info->ref_idx[LIST_1]];
1203 }
1204 }
1205
1206 for (k = k_start; k < k_end; k ++)
1207 {
1208 int i = (decode_block_scan[k] & 3);
1209 int j = ((decode_block_scan[k] >> 2) & 3);
1210 perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, block_size_x, block_size_y);
1211 }
1212 }
1213 }
1214
1215 iTransform(currMB, curr_plane, 0);
1216 if (currMB->cbp != 0)
1217 currSlice->is_reset_coeff = FALSE;
1218 return 1;
1219 }
1220
1221 /*!
1222 ************************************************************************
1223 * \brief
1224 * Copy IPCM coefficients to decoded picture buffer and set parameters for this MB
1225 * (for IPCM CABAC and IPCM CAVLC 28/11/2003)
1226 *
1227 * \author
1228 * Dong Wang <Dong.Wang@bristol.ac.uk>
1229 ************************************************************************
1230 */
1231
mb_pred_ipcm(Macroblock * currMB)1232 int mb_pred_ipcm(Macroblock *currMB)
1233 {
1234 int i, j, k;
1235 Slice *currSlice = currMB->p_Slice;
1236 VideoParameters *p_Vid = currMB->p_Vid;
1237 StorablePicture *dec_picture = currSlice->dec_picture;
1238
1239 //Copy coefficients to decoded picture buffer
1240 //IPCM coefficients are stored in currSlice->cof which is set in function read_IPCM_coeffs_from_NAL()
1241
1242 for(i = 0; i < MB_BLOCK_SIZE; ++i)
1243 {
1244 for(j = 0;j < MB_BLOCK_SIZE ; ++j)
1245 {
1246 dec_picture->imgY[currMB->pix_y + i][currMB->pix_x + j] = (imgpel) currSlice->cof[0][i][j];
1247 }
1248 }
1249
1250 if ((dec_picture->chroma_format_idc != YUV400) && (p_Vid->separate_colour_plane_flag == 0))
1251 {
1252 for (k = 0; k < 2; ++k)
1253 {
1254 for(i = 0; i < p_Vid->mb_cr_size_y; ++i)
1255 {
1256 for(j = 0;j < p_Vid->mb_cr_size_x; ++j)
1257 {
1258 dec_picture->imgUV[k][currMB->pix_c_y+i][currMB->pix_c_x + j] = (imgpel) currSlice->cof[k + 1][i][j];
1259 }
1260 }
1261 }
1262 }
1263
1264 // for deblocking filter
1265 update_qp(currMB, 0);
1266
1267 // for CAVLC: Set the nz_coeff to 16.
1268 // These parameters are to be used in CAVLC decoding of neighbour blocks
1269 memset(p_Vid->nz_coeff[currMB->mbAddrX][0][0], 16, 3 * BLOCK_PIXELS * sizeof(byte));
1270
1271 // for CABAC decoding of MB skip flag
1272 currMB->skip_flag = 0;
1273
1274 //for deblocking filter CABAC
1275 currMB->s_cbp[0].blk = 0xFFFF;
1276
1277 //For CABAC decoding of Dquant
1278 currSlice->last_dquant = 0;
1279 currSlice->is_reset_coeff = FALSE;
1280 currSlice->is_reset_coeff_cr = FALSE;
1281 return 1;
1282 }
1283
1284