Fix compilation with -O0.
[ffmpeg.git] / libavcodec / h264_direct.c
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... direct mb/block decoding
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file libavcodec/h264_direct.c
24  * H.264 / AVC / MPEG4 part10 direct mb/block decoding.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27
28 #include "internal.h"
29 #include "dsputil.h"
30 #include "avcodec.h"
31 #include "mpegvideo.h"
32 #include "h264.h"
33 #include "h264_mvpred.h"
34 #include "rectangle.h"
35
36 //#undef NDEBUG
37 #include <assert.h>
38
39
40 static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){
41     int poc0 = h->ref_list[0][i].poc;
42     int td = av_clip(poc1 - poc0, -128, 127);
43     if(td == 0 || h->ref_list[0][i].long_ref){
44         return 256;
45     }else{
46         int tb = av_clip(poc - poc0, -128, 127);
47         int tx = (16384 + (FFABS(td) >> 1)) / td;
48         return av_clip((tb*tx + 32) >> 6, -1024, 1023);
49     }
50 }
51
52 void ff_h264_direct_dist_scale_factor(H264Context * const h){
53     MpegEncContext * const s = &h->s;
54     const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
55     const int poc1 = h->ref_list[1][0].poc;
56     int i, field;
57     for(field=0; field<2; field++){
58         const int poc  = h->s.current_picture_ptr->field_poc[field];
59         const int poc1 = h->ref_list[1][0].field_poc[field];
60         for(i=0; i < 2*h->ref_count[0]; i++)
61             h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16);
62     }
63
64     for(i=0; i<h->ref_count[0]; i++){
65         h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);
66     }
67 }
68
69 static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){
70     MpegEncContext * const s = &h->s;
71     Picture * const ref1 = &h->ref_list[1][0];
72     int j, old_ref, rfield;
73     int start= mbafi ? 16                      : 0;
74     int end  = mbafi ? 16+2*h->ref_count[list] : h->ref_count[list];
75     int interl= mbafi || s->picture_structure != PICT_FRAME;
76
77     /* bogus; fills in for missing frames */
78     memset(map[list], 0, sizeof(map[list]));
79
80     for(rfield=0; rfield<2; rfield++){
81         for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){
82             int poc = ref1->ref_poc[colfield][list][old_ref];
83
84             if     (!interl)
85                 poc |= 3;
86             else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed
87                 poc= (poc&~3) + rfield + 1;
88
89             for(j=start; j<end; j++){
90                 if(4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3) == poc){
91                     int cur_ref= mbafi ? (j-16)^field : j;
92                     map[list][2*old_ref + (rfield^field) + 16] = cur_ref;
93                     if(rfield == field)
94                         map[list][old_ref] = cur_ref;
95                     break;
96                 }
97             }
98         }
99     }
100 }
101
102 void ff_h264_direct_ref_list_init(H264Context * const h){
103     MpegEncContext * const s = &h->s;
104     Picture * const ref1 = &h->ref_list[1][0];
105     Picture * const cur = s->current_picture_ptr;
106     int list, j, field;
107     int sidx= (s->picture_structure&1)^1;
108     int ref1sidx= (ref1->reference&1)^1;
109
110     for(list=0; list<2; list++){
111         cur->ref_count[sidx][list] = h->ref_count[list];
112         for(j=0; j<h->ref_count[list]; j++)
113             cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3);
114     }
115
116     if(s->picture_structure == PICT_FRAME){
117         memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));
118         memcpy(cur->ref_poc  [1], cur->ref_poc  [0], sizeof(cur->ref_poc  [0]));
119     }
120
121     cur->mbaff= FRAME_MBAFF;
122
123     if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)
124         return;
125
126     for(list=0; list<2; list++){
127         fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);
128         for(field=0; field<2; field++)
129             fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);
130     }
131 }
132
133 void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){
134     MpegEncContext * const s = &h->s;
135     int b8_stride = h->b8_stride;
136     int b4_stride = h->b_stride;
137     int mb_xy = h->mb_xy;
138     int mb_type_col[2];
139     const int16_t (*l1mv0)[2], (*l1mv1)[2];
140     const int8_t *l1ref0, *l1ref1;
141     const int is_b8x8 = IS_8X8(*mb_type);
142     unsigned int sub_mb_type;
143     int i8, i4;
144
145     assert(h->ref_list[1][0].reference&3);
146
147 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
148
149     if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
150         if(!IS_INTERLACED(*mb_type)){                    //     AFR/FR    -> AFL/FL
151             int cur_poc = s->current_picture_ptr->poc;
152             int *col_poc = h->ref_list[1]->field_poc;
153             int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);
154             mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;
155             b8_stride = 0;
156         }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity
157             int fieldoff= 2*(h->ref_list[1][0].reference)-3;
158             mb_xy += s->mb_stride*fieldoff;
159         }
160         goto single_col;
161     }else{                                               // AFL/AFR/FR/FL -> AFR/FR
162         if(IS_INTERLACED(*mb_type)){                     // AFL       /FL -> AFR/FR
163             mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;
164             mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
165             mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
166             b8_stride *= 3;
167             b4_stride *= 6;
168             //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag
169             if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)
170                 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)
171                 && !is_b8x8){
172                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
173                 *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */
174             }else{
175                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
176                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
177             }
178         }else{                                           //     AFR/FR    -> AFR/FR
179 single_col:
180             mb_type_col[0] =
181             mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];
182             if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){
183                 /* FIXME save sub mb types from previous frames (or derive from MVs)
184                 * so we know exactly what block size to use */
185                 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
186                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
187             }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){
188                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
189                 *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
190             }else{
191                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
192                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
193             }
194         }
195     }
196
197     l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
198     l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
199     l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];
200     l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];
201     if(!b8_stride){
202         if(s->mb_y&1){
203             l1ref0 += h->b8_stride;
204             l1ref1 += h->b8_stride;
205             l1mv0  +=  2*b4_stride;
206             l1mv1  +=  2*b4_stride;
207         }
208     }
209
210     if(h->direct_spatial_mv_pred){
211         int ref[2];
212         int mv[2][2];
213         int list;
214
215         /* FIXME interlacing + spatial direct uses wrong colocated block positions */
216
217         /* ref = min(neighbors) */
218         for(list=0; list<2; list++){
219             int refa = h->ref_cache[list][scan8[0] - 1];
220             int refb = h->ref_cache[list][scan8[0] - 8];
221             int refc = h->ref_cache[list][scan8[0] - 8 + 4];
222             if(refc == PART_NOT_AVAILABLE)
223                 refc = h->ref_cache[list][scan8[0] - 8 - 1];
224             ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);
225             if(ref[list] < 0)
226                 ref[list] = -1;
227         }
228
229         if(ref[0] < 0 && ref[1] < 0){
230             ref[0] = ref[1] = 0;
231             mv[0][0] = mv[0][1] =
232             mv[1][0] = mv[1][1] = 0;
233         }else{
234             for(list=0; list<2; list++){
235                 if(ref[list] >= 0)
236                     pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
237                 else
238                     mv[list][0] = mv[list][1] = 0;
239             }
240         }
241
242         if(ref[1] < 0){
243             if(!is_b8x8)
244                 *mb_type &= ~MB_TYPE_L1;
245             sub_mb_type &= ~MB_TYPE_L1;
246         }else if(ref[0] < 0){
247             if(!is_b8x8)
248                 *mb_type &= ~MB_TYPE_L0;
249             sub_mb_type &= ~MB_TYPE_L0;
250         }
251
252         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
253             for(i8=0; i8<4; i8++){
254                 int x8 = i8&1;
255                 int y8 = i8>>1;
256                 int xy8 = x8+y8*b8_stride;
257                 int xy4 = 3*x8+y8*b4_stride;
258                 int a=0, b=0;
259
260                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
261                     continue;
262                 h->sub_mb_type[i8] = sub_mb_type;
263
264                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
265                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
266                 if(!IS_INTRA(mb_type_col[y8])
267                    && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)
268                        || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){
269                     if(ref[0] > 0)
270                         a= pack16to32(mv[0][0],mv[0][1]);
271                     if(ref[1] > 0)
272                         b= pack16to32(mv[1][0],mv[1][1]);
273                 }else{
274                     a= pack16to32(mv[0][0],mv[0][1]);
275                     b= pack16to32(mv[1][0],mv[1][1]);
276                 }
277                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);
278                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);
279             }
280         }else if(IS_16X16(*mb_type)){
281             int a=0, b=0;
282
283             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
284             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
285             if(!IS_INTRA(mb_type_col[0])
286                && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
287                    || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
288                        && (h->x264_build>33 || !h->x264_build)))){
289                 if(ref[0] > 0)
290                     a= pack16to32(mv[0][0],mv[0][1]);
291                 if(ref[1] > 0)
292                     b= pack16to32(mv[1][0],mv[1][1]);
293             }else{
294                 a= pack16to32(mv[0][0],mv[0][1]);
295                 b= pack16to32(mv[1][0],mv[1][1]);
296             }
297             fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
298             fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
299         }else{
300             for(i8=0; i8<4; i8++){
301                 const int x8 = i8&1;
302                 const int y8 = i8>>1;
303
304                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
305                     continue;
306                 h->sub_mb_type[i8] = sub_mb_type;
307
308                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
309                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
310                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
311                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
312
313                 /* col_zero_flag */
314                 if(!IS_INTRA(mb_type_col[0]) && (   l1ref0[x8 + y8*b8_stride] == 0
315                                               || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0
316                                                   && (h->x264_build>33 || !h->x264_build)))){
317                     const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;
318                     if(IS_SUB_8X8(sub_mb_type)){
319                         const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
320                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
321                             if(ref[0] == 0)
322                                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
323                             if(ref[1] == 0)
324                                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
325                         }
326                     }else
327                     for(i4=0; i4<4; i4++){
328                         const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
329                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
330                             if(ref[0] == 0)
331                                 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
332                             if(ref[1] == 0)
333                                 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
334                         }
335                     }
336                 }
337             }
338         }
339     }else{ /* direct temporal mv pred */
340         const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
341         const int *dist_scale_factor = h->dist_scale_factor;
342         int ref_offset= 0;
343
344         if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){
345             map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];
346             map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];
347             dist_scale_factor   =h->dist_scale_factor_field[s->mb_y&1];
348         }
349         if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))
350             ref_offset += 16;
351
352         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
353             /* FIXME assumes direct_8x8_inference == 1 */
354             int y_shift  = 2*!IS_INTERLACED(*mb_type);
355
356             for(i8=0; i8<4; i8++){
357                 const int x8 = i8&1;
358                 const int y8 = i8>>1;
359                 int ref0, scale;
360                 const int16_t (*l1mv)[2]= l1mv0;
361
362                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
363                     continue;
364                 h->sub_mb_type[i8] = sub_mb_type;
365
366                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
367                 if(IS_INTRA(mb_type_col[y8])){
368                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
369                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
370                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
371                     continue;
372                 }
373
374                 ref0 = l1ref0[x8 + y8*b8_stride];
375                 if(ref0 >= 0)
376                     ref0 = map_col_to_list0[0][ref0 + ref_offset];
377                 else{
378                     ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
379                     l1mv= l1mv1;
380                 }
381                 scale = dist_scale_factor[ref0];
382                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
383
384                 {
385                     const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride];
386                     int my_col = (mv_col[1]<<y_shift)/2;
387                     int mx = (scale * mv_col[0] + 128) >> 8;
388                     int my = (scale * my_col + 128) >> 8;
389                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
390                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);
391                 }
392             }
393             return;
394         }
395
396         /* one-to-one mv scaling */
397
398         if(IS_16X16(*mb_type)){
399             int ref, mv0, mv1;
400
401             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
402             if(IS_INTRA(mb_type_col[0])){
403                 ref=mv0=mv1=0;
404             }else{
405                 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
406                                                 : map_col_to_list0[1][l1ref1[0] + ref_offset];
407                 const int scale = dist_scale_factor[ref0];
408                 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
409                 int mv_l0[2];
410                 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
411                 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
412                 ref= ref0;
413                 mv0= pack16to32(mv_l0[0],mv_l0[1]);
414                 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
415             }
416             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
417             fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);
418             fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);
419         }else{
420             for(i8=0; i8<4; i8++){
421                 const int x8 = i8&1;
422                 const int y8 = i8>>1;
423                 int ref0, scale;
424                 const int16_t (*l1mv)[2]= l1mv0;
425
426                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
427                     continue;
428                 h->sub_mb_type[i8] = sub_mb_type;
429                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
430                 if(IS_INTRA(mb_type_col[0])){
431                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
432                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
433                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
434                     continue;
435                 }
436
437                 ref0 = l1ref0[x8 + y8*b8_stride] + ref_offset;
438                 if(ref0 >= 0)
439                     ref0 = map_col_to_list0[0][ref0];
440                 else{
441                     ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
442                     l1mv= l1mv1;
443                 }
444                 scale = dist_scale_factor[ref0];
445
446                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
447                 if(IS_SUB_8X8(sub_mb_type)){
448                     const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
449                     int mx = (scale * mv_col[0] + 128) >> 8;
450                     int my = (scale * mv_col[1] + 128) >> 8;
451                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
452                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
453                 }else
454                 for(i4=0; i4<4; i4++){
455                     const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
456                     int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
457                     mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
458                     mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
459                     *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
460                         pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
461                 }
462             }
463         }
464     }
465 }