sync with linuxport @ 18013
[xbmc:xbmc-antiquated.git] / xbmc / cores / dvdplayer / Codecs / ffmpeg / libavcodec / h264.c
1 /*\r
2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder\r
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>\r
4  *\r
5  * This file is part of FFmpeg.\r
6  *\r
7  * FFmpeg is free software; you can redistribute it and/or\r
8  * modify it under the terms of the GNU Lesser General Public\r
9  * License as published by the Free Software Foundation; either\r
10  * version 2.1 of the License, or (at your option) any later version.\r
11  *\r
12  * FFmpeg is distributed in the hope that it will be useful,\r
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
15  * Lesser General Public License for more details.\r
16  *\r
17  * You should have received a copy of the GNU Lesser General Public\r
18  * License along with FFmpeg; if not, write to the Free Software\r
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\r
20  */\r
21 \r
22 /**\r
23  * @file libavcodec/h264.c\r
24  * H.264 / AVC / MPEG4 part10 codec.\r
25  * @author Michael Niedermayer <michaelni@gmx.at>\r
26  */\r
27 \r
28 #include "dsputil.h"\r
29 #include "avcodec.h"\r
30 #include "mpegvideo.h"\r
31 #include "h264.h"\r
32 #include "h264data.h"\r
33 #include "h264_parser.h"\r
34 #include "golomb.h"\r
35 #include "mathops.h"\r
36 #include "rectangle.h"\r
37 #include "vdpau_internal.h"\r
38 \r
39 #include "cabac.h"\r
40 #if ARCH_X86\r
41 #include "x86/h264_i386.h"\r
42 #endif\r
43 \r
44 //#undef NDEBUG\r
45 #include <assert.h>\r
46 \r
47 /**\r
48  * Value of Picture.reference when Picture is not a reference picture, but\r
49  * is held for delayed output.\r
50  */\r
51 #define DELAYED_PIC_REF 4\r
52 \r
53 static VLC coeff_token_vlc[4];\r
54 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];\r
55 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};\r
56 \r
57 static VLC chroma_dc_coeff_token_vlc;\r
58 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];\r
59 static const int chroma_dc_coeff_token_vlc_table_size = 256;\r
60 \r
61 static VLC total_zeros_vlc[15];\r
62 static VLC_TYPE total_zeros_vlc_tables[15][512][2];\r
63 static const int total_zeros_vlc_tables_size = 512;\r
64 \r
65 static VLC chroma_dc_total_zeros_vlc[3];\r
66 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];\r
67 static const int chroma_dc_total_zeros_vlc_tables_size = 8;\r
68 \r
69 static VLC run_vlc[6];\r
70 static VLC_TYPE run_vlc_tables[6][8][2];\r
71 static const int run_vlc_tables_size = 8;\r
72 \r
73 static VLC run7_vlc;\r
74 static VLC_TYPE run7_vlc_table[96][2];\r
75 static const int run7_vlc_table_size = 96;\r
76 \r
77 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);\r
78 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);\r
79 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);\r
80 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);\r
81 static Picture * remove_long(H264Context *h, int i, int ref_mask);\r
82 \r
83 static av_always_inline uint32_t pack16to32(int a, int b){\r
84 #ifdef WORDS_BIGENDIAN\r
85    return (b&0xFFFF) + (a<<16);\r
86 #else\r
87    return (a&0xFFFF) + (b<<16);\r
88 #endif\r
89 }\r
90 \r
91 static const uint8_t rem6[52]={\r
92 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,\r
93 };\r
94 \r
95 static const uint8_t div6[52]={\r
96 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,\r
97 };\r
98 \r
99 static const uint8_t left_block_options[4][8]={\r
100     {0,1,2,3,7,10,8,11},\r
101     {2,2,3,3,8,11,8,11},\r
102     {0,0,1,1,7,10,7,10},\r
103     {0,2,0,2,7,10,7,10}\r
104 };\r
105 \r
106 #define LEVEL_TAB_BITS 8\r
107 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];\r
108 \r
109 static void fill_caches(H264Context *h, int mb_type, int for_deblock){\r
110     MpegEncContext * const s = &h->s;\r
111     const int mb_xy= h->mb_xy;\r
112     int topleft_xy, top_xy, topright_xy, left_xy[2];\r
113     int topleft_type, top_type, topright_type, left_type[2];\r
114     const uint8_t * left_block;\r
115     int topleft_partition= -1;\r
116     int i;\r
117 \r
118     top_xy     = mb_xy  - (s->mb_stride << FIELD_PICTURE);\r
119 \r
120     //FIXME deblocking could skip the intra and nnz parts.\r
121     if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)\r
122         return;\r
123 \r
124     /* Wow, what a mess, why didn't they simplify the interlacing & intra\r
125      * stuff, I can't imagine that these complex rules are worth it. */\r
126 \r
127     topleft_xy = top_xy - 1;\r
128     topright_xy= top_xy + 1;\r
129     left_xy[1] = left_xy[0] = mb_xy-1;\r
130     left_block = left_block_options[0];\r
131     if(FRAME_MBAFF){\r
132         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;\r
133         const int top_pair_xy      = pair_xy     - s->mb_stride;\r
134         const int topleft_pair_xy  = top_pair_xy - 1;\r
135         const int topright_pair_xy = top_pair_xy + 1;\r
136         const int topleft_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);\r
137         const int top_mb_field_flag      = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);\r
138         const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);\r
139         const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);\r
140         const int curr_mb_field_flag     = IS_INTERLACED(mb_type);\r
141         const int bottom = (s->mb_y & 1);\r
142         tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag);\r
143 \r
144         if (curr_mb_field_flag && (bottom || top_mb_field_flag)){\r
145             top_xy -= s->mb_stride;\r
146         }\r
147         if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){\r
148             topleft_xy -= s->mb_stride;\r
149         } else if(bottom && !curr_mb_field_flag && left_mb_field_flag) {\r
150             topleft_xy += s->mb_stride;\r
151             // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition\r
152             topleft_partition = 0;\r
153         }\r
154         if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){\r
155             topright_xy -= s->mb_stride;\r
156         }\r
157         if (left_mb_field_flag != curr_mb_field_flag) {\r
158             left_xy[1] = left_xy[0] = pair_xy - 1;\r
159             if (curr_mb_field_flag) {\r
160                 left_xy[1] += s->mb_stride;\r
161                 left_block = left_block_options[3];\r
162             } else {\r
163                 left_block= left_block_options[2 - bottom];\r
164             }\r
165         }\r
166     }\r
167 \r
168     h->top_mb_xy = top_xy;\r
169     h->left_mb_xy[0] = left_xy[0];\r
170     h->left_mb_xy[1] = left_xy[1];\r
171     if(for_deblock){\r
172         topleft_type = 0;\r
173         topright_type = 0;\r
174         top_type     = h->slice_table[top_xy     ] < 0xFFFF ? s->current_picture.mb_type[top_xy]     : 0;\r
175         left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;\r
176         left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;\r
177 \r
178         if(MB_MBAFF && !IS_INTRA(mb_type)){\r
179             int list;\r
180             for(list=0; list<h->list_count; list++){\r
181                 //These values where changed for ease of performing MC, we need to change them back\r
182                 //FIXME maybe we can make MC and loop filter use the same values or prevent\r
183                 //the MC code from changing ref_cache and rather use a temporary array.\r
184                 if(USES_LIST(mb_type,list)){\r
185                     int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];\r
186                     *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =\r
187                     *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;\r
188                     ref += h->b8_stride;\r
189                     *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =\r
190                     *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;\r
191                 }\r
192             }\r
193         }\r
194     }else{\r
195         topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;\r
196         top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;\r
197         topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;\r
198         left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;\r
199         left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;\r
200 \r
201     if(IS_INTRA(mb_type)){\r
202         int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;\r
203         h->topleft_samples_available=\r
204         h->top_samples_available=\r
205         h->left_samples_available= 0xFFFF;\r
206         h->topright_samples_available= 0xEEEA;\r
207 \r
208         if(!(top_type & type_mask)){\r
209             h->topleft_samples_available= 0xB3FF;\r
210             h->top_samples_available= 0x33FF;\r
211             h->topright_samples_available= 0x26EA;\r
212         }\r
213         if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){\r
214             if(IS_INTERLACED(mb_type)){\r
215                 if(!(left_type[0] & type_mask)){\r
216                     h->topleft_samples_available&= 0xDFFF;\r
217                     h->left_samples_available&= 0x5FFF;\r
218                 }\r
219                 if(!(left_type[1] & type_mask)){\r
220                     h->topleft_samples_available&= 0xFF5F;\r
221                     h->left_samples_available&= 0xFF5F;\r
222                 }\r
223             }else{\r
224                 int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num\r
225                                 ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0;\r
226                 assert(left_xy[0] == left_xy[1]);\r
227                 if(!((left_typei & type_mask) && (left_type[0] & type_mask))){\r
228                     h->topleft_samples_available&= 0xDF5F;\r
229                     h->left_samples_available&= 0x5F5F;\r
230                 }\r
231             }\r
232         }else{\r
233             if(!(left_type[0] & type_mask)){\r
234                 h->topleft_samples_available&= 0xDF5F;\r
235                 h->left_samples_available&= 0x5F5F;\r
236             }\r
237         }\r
238 \r
239         if(!(topleft_type & type_mask))\r
240             h->topleft_samples_available&= 0x7FFF;\r
241 \r
242         if(!(topright_type & type_mask))\r
243             h->topright_samples_available&= 0xFBFF;\r
244 \r
245         if(IS_INTRA4x4(mb_type)){\r
246             if(IS_INTRA4x4(top_type)){\r
247                 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];\r
248                 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];\r
249                 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];\r
250                 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];\r
251             }else{\r
252                 int pred;\r
253                 if(!(top_type & type_mask))\r
254                     pred= -1;\r
255                 else{\r
256                     pred= 2;\r
257                 }\r
258                 h->intra4x4_pred_mode_cache[4+8*0]=\r
259                 h->intra4x4_pred_mode_cache[5+8*0]=\r
260                 h->intra4x4_pred_mode_cache[6+8*0]=\r
261                 h->intra4x4_pred_mode_cache[7+8*0]= pred;\r
262             }\r
263             for(i=0; i<2; i++){\r
264                 if(IS_INTRA4x4(left_type[i])){\r
265                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];\r
266                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];\r
267                 }else{\r
268                     int pred;\r
269                     if(!(left_type[i] & type_mask))\r
270                         pred= -1;\r
271                     else{\r
272                         pred= 2;\r
273                     }\r
274                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=\r
275                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;\r
276                 }\r
277             }\r
278         }\r
279     }\r
280     }\r
281 \r
282 \r
283 /*\r
284 0 . T T. T T T T\r
285 1 L . .L . . . .\r
286 2 L . .L . . . .\r
287 3 . T TL . . . .\r
288 4 L . .L . . . .\r
289 5 L . .. . . . .\r
290 */\r
291 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)\r
292     if(top_type){\r
293         h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];\r
294         h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];\r
295         h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];\r
296         h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];\r
297 \r
298         h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];\r
299         h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];\r
300 \r
301         h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];\r
302         h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];\r
303 \r
304     }else{\r
305         h->non_zero_count_cache[4+8*0]=\r
306         h->non_zero_count_cache[5+8*0]=\r
307         h->non_zero_count_cache[6+8*0]=\r
308         h->non_zero_count_cache[7+8*0]=\r
309 \r
310         h->non_zero_count_cache[1+8*0]=\r
311         h->non_zero_count_cache[2+8*0]=\r
312 \r
313         h->non_zero_count_cache[1+8*3]=\r
314         h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;\r
315 \r
316     }\r
317 \r
318     for (i=0; i<2; i++) {\r
319         if(left_type[i]){\r
320             h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];\r
321             h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];\r
322             h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];\r
323             h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];\r
324         }else{\r
325             h->non_zero_count_cache[3+8*1 + 2*8*i]=\r
326             h->non_zero_count_cache[3+8*2 + 2*8*i]=\r
327             h->non_zero_count_cache[0+8*1 +   8*i]=\r
328             h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;\r
329         }\r
330     }\r
331 \r
332     if( h->pps.cabac ) {\r
333         // top_cbp\r
334         if(top_type) {\r
335             h->top_cbp = h->cbp_table[top_xy];\r
336         } else if(IS_INTRA(mb_type)) {\r
337             h->top_cbp = 0x1C0;\r
338         } else {\r
339             h->top_cbp = 0;\r
340         }\r
341         // left_cbp\r
342         if (left_type[0]) {\r
343             h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;\r
344         } else if(IS_INTRA(mb_type)) {\r
345             h->left_cbp = 0x1C0;\r
346         } else {\r
347             h->left_cbp = 0;\r
348         }\r
349         if (left_type[0]) {\r
350             h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;\r
351         }\r
352         if (left_type[1]) {\r
353             h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;\r
354         }\r
355     }\r
356 \r
357 #if 1\r
358     if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){\r
359         int list;\r
360         for(list=0; list<h->list_count; list++){\r
361             if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){\r
362                 /*if(!h->mv_cache_clean[list]){\r
363                     memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?\r
364                     memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));\r
365                     h->mv_cache_clean[list]= 1;\r
366                 }*/\r
367                 continue;\r
368             }\r
369             h->mv_cache_clean[list]= 0;\r
370 \r
371             if(USES_LIST(top_type, list)){\r
372                 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;\r
373                 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;\r
374                 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];\r
375                 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];\r
376                 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];\r
377                 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];\r
378                 h->ref_cache[list][scan8[0] + 0 - 1*8]=\r
379                 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];\r
380                 h->ref_cache[list][scan8[0] + 2 - 1*8]=\r
381                 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];\r
382             }else{\r
383                 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=\r
384                 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=\r
385                 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=\r
386                 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;\r
387                 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;\r
388             }\r
389 \r
390             for(i=0; i<2; i++){\r
391                 int cache_idx = scan8[0] - 1 + i*2*8;\r
392                 if(USES_LIST(left_type[i], list)){\r
393                     const int b_xy= h->mb2b_xy[left_xy[i]] + 3;\r
394                     const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1;\r
395                     *(uint32_t*)h->mv_cache[list][cache_idx  ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]];\r
396                     *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]];\r
397                     h->ref_cache[list][cache_idx  ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)];\r
398                     h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)];\r
399                 }else{\r
400                     *(uint32_t*)h->mv_cache [list][cache_idx  ]=\r
401                     *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0;\r
402                     h->ref_cache[list][cache_idx  ]=\r
403                     h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE;\r
404                 }\r
405             }\r
406 \r
407             if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF))\r
408                 continue;\r
409 \r
410             if(USES_LIST(topleft_type, list)){\r
411                 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride);\r
412                 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride);\r
413                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];\r
414                 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];\r
415             }else{\r
416                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;\r
417                 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;\r
418             }\r
419 \r
420             if(USES_LIST(topright_type, list)){\r
421                 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;\r
422                 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;\r
423                 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];\r
424                 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];\r
425             }else{\r
426                 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;\r
427                 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;\r
428             }\r
429 \r
430             if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)\r
431                 continue;\r
432 \r
433             h->ref_cache[list][scan8[5 ]+1] =\r
434             h->ref_cache[list][scan8[7 ]+1] =\r
435             h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)\r
436             h->ref_cache[list][scan8[4 ]] =\r
437             h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;\r
438             *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=\r
439             *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=\r
440             *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)\r
441             *(uint32_t*)h->mv_cache [list][scan8[4 ]]=\r
442             *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;\r
443 \r
444             if( h->pps.cabac ) {\r
445                 /* XXX beurk, Load mvd */\r
446                 if(USES_LIST(top_type, list)){\r
447                     const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;\r
448                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];\r
449                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];\r
450                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];\r
451                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];\r
452                 }else{\r
453                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=\r
454                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=\r
455                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=\r
456                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;\r
457                 }\r
458                 if(USES_LIST(left_type[0], list)){\r
459                     const int b_xy= h->mb2b_xy[left_xy[0]] + 3;\r
460                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]];\r
461                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]];\r
462                 }else{\r
463                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=\r
464                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;\r
465                 }\r
466                 if(USES_LIST(left_type[1], list)){\r
467                     const int b_xy= h->mb2b_xy[left_xy[1]] + 3;\r
468                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]];\r
469                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]];\r
470                 }else{\r
471                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=\r
472                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;\r
473                 }\r
474                 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=\r
475                 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=\r
476                 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)\r
477                 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=\r
478                 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;\r
479 \r
480                 if(h->slice_type_nos == FF_B_TYPE){\r
481                     fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);\r
482 \r
483                     if(IS_DIRECT(top_type)){\r
484                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;\r
485                     }else if(IS_8X8(top_type)){\r
486                         int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;\r
487                         h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];\r
488                         h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];\r
489                     }else{\r
490                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;\r
491                     }\r
492 \r
493                     if(IS_DIRECT(left_type[0]))\r
494                         h->direct_cache[scan8[0] - 1 + 0*8]= 1;\r
495                     else if(IS_8X8(left_type[0]))\r
496                         h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];\r
497                     else\r
498                         h->direct_cache[scan8[0] - 1 + 0*8]= 0;\r
499 \r
500                     if(IS_DIRECT(left_type[1]))\r
501                         h->direct_cache[scan8[0] - 1 + 2*8]= 1;\r
502                     else if(IS_8X8(left_type[1]))\r
503                         h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];\r
504                     else\r
505                         h->direct_cache[scan8[0] - 1 + 2*8]= 0;\r
506                 }\r
507             }\r
508 \r
509             if(FRAME_MBAFF){\r
510 #define MAP_MVS\\r
511                     MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\\r
512                     MAP_F2F(scan8[0] + 0 - 1*8, top_type)\\r
513                     MAP_F2F(scan8[0] + 1 - 1*8, top_type)\\r
514                     MAP_F2F(scan8[0] + 2 - 1*8, top_type)\\r
515                     MAP_F2F(scan8[0] + 3 - 1*8, top_type)\\r
516                     MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\\r
517                     MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\\r
518                     MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\\r
519                     MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\\r
520                     MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])\r
521                 if(MB_FIELD){\r
522 #define MAP_F2F(idx, mb_type)\\r
523                     if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\\r
524                         h->ref_cache[list][idx] <<= 1;\\r
525                         h->mv_cache[list][idx][1] /= 2;\\r
526                         h->mvd_cache[list][idx][1] /= 2;\\r
527                     }\r
528                     MAP_MVS\r
529 #undef MAP_F2F\r
530                 }else{\r
531 #define MAP_F2F(idx, mb_type)\\r
532                     if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\\r
533                         h->ref_cache[list][idx] >>= 1;\\r
534                         h->mv_cache[list][idx][1] <<= 1;\\r
535                         h->mvd_cache[list][idx][1] <<= 1;\\r
536                     }\r
537                     MAP_MVS\r
538 #undef MAP_F2F\r
539                 }\r
540             }\r
541         }\r
542     }\r
543 #endif\r
544 \r
545     h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);\r
546 }\r
547 \r
548 static inline void write_back_intra_pred_mode(H264Context *h){\r
549     const int mb_xy= h->mb_xy;\r
550 \r
551     h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];\r
552     h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];\r
553     h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];\r
554     h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];\r
555     h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];\r
556     h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];\r
557     h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];\r
558 }\r
559 \r
560 /**\r
561  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.\r
562  */\r
563 static inline int check_intra4x4_pred_mode(H264Context *h){\r
564     MpegEncContext * const s = &h->s;\r
565     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};\r
566     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};\r
567     int i;\r
568 \r
569     if(!(h->top_samples_available&0x8000)){\r
570         for(i=0; i<4; i++){\r
571             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];\r
572             if(status<0){\r
573                 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);\r
574                 return -1;\r
575             } else if(status){\r
576                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;\r
577             }\r
578         }\r
579     }\r
580 \r
581     if((h->left_samples_available&0x8888)!=0x8888){\r
582         static const int mask[4]={0x8000,0x2000,0x80,0x20};\r
583         for(i=0; i<4; i++){\r
584             if(!(h->left_samples_available&mask[i])){\r
585                 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];\r
586                 if(status<0){\r
587                     av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);\r
588                     return -1;\r
589                 } else if(status){\r
590                     h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;\r
591                 }\r
592             }\r
593         }\r
594     }\r
595 \r
596     return 0;\r
597 } //FIXME cleanup like next\r
598 \r
599 /**\r
600  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.\r
601  */\r
602 static inline int check_intra_pred_mode(H264Context *h, int mode){\r
603     MpegEncContext * const s = &h->s;\r
604     static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};\r
605     static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};\r
606 \r
607     if(mode > 6U) {\r
608         av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);\r
609         return -1;\r
610     }\r
611 \r
612     if(!(h->top_samples_available&0x8000)){\r
613         mode= top[ mode ];\r
614         if(mode<0){\r
615             av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);\r
616             return -1;\r
617         }\r
618     }\r
619 \r
620     if((h->left_samples_available&0x8080) != 0x8080){\r
621         mode= left[ mode ];\r
622         if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred\r
623             mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);\r
624         }\r
625         if(mode<0){\r
626             av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);\r
627             return -1;\r
628         }\r
629     }\r
630 \r
631     return mode;\r
632 }\r
633 \r
634 /**\r
635  * gets the predicted intra4x4 prediction mode.\r
636  */\r
637 static inline int pred_intra_mode(H264Context *h, int n){\r
638     const int index8= scan8[n];\r
639     const int left= h->intra4x4_pred_mode_cache[index8 - 1];\r
640     const int top = h->intra4x4_pred_mode_cache[index8 - 8];\r
641     const int min= FFMIN(left, top);\r
642 \r
643     tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min);\r
644 \r
645     if(min<0) return DC_PRED;\r
646     else      return min;\r
647 }\r
648 \r
649 static inline void write_back_non_zero_count(H264Context *h){\r
650     const int mb_xy= h->mb_xy;\r
651 \r
652     h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];\r
653     h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];\r
654     h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];\r
655     h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];\r
656     h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];\r
657     h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];\r
658     h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];\r
659 \r
660     h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];\r
661     h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];\r
662     h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];\r
663 \r
664     h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];\r
665     h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];\r
666     h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];\r
667 }\r
668 \r
669 /**\r
670  * gets the predicted number of non-zero coefficients.\r
671  * @param n block index\r
672  */\r
673 static inline int pred_non_zero_count(H264Context *h, int n){\r
674     const int index8= scan8[n];\r
675     const int left= h->non_zero_count_cache[index8 - 1];\r
676     const int top = h->non_zero_count_cache[index8 - 8];\r
677     int i= left + top;\r
678 \r
679     if(i<64) i= (i+1)>>1;\r
680 \r
681     tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);\r
682 \r
683     return i&31;\r
684 }\r
685 \r
686 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){\r
687     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];\r
688     MpegEncContext *s = &h->s;\r
689 \r
690     /* there is no consistent mapping of mvs to neighboring locations that will\r
691      * make mbaff happy, so we can't move all this logic to fill_caches */\r
692     if(FRAME_MBAFF){\r
693         const uint32_t *mb_types = s->current_picture_ptr->mb_type;\r
694         const int16_t *mv;\r
695         *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;\r
696         *C = h->mv_cache[list][scan8[0]-2];\r
697 \r
698         if(!MB_FIELD\r
699            && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){\r
700             int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);\r
701             if(IS_INTERLACED(mb_types[topright_xy])){\r
702 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\\r
703                 const int x4 = X4, y4 = Y4;\\r
704                 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\\r
705                 if(!USES_LIST(mb_type,list))\\r
706                     return LIST_NOT_USED;\\r
707                 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\\r
708                 h->mv_cache[list][scan8[0]-2][0] = mv[0];\\r
709                 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\\r
710                 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;\r
711 \r
712                 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);\r
713             }\r
714         }\r
715         if(topright_ref == PART_NOT_AVAILABLE\r
716            && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4\r
717            && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){\r
718             if(!MB_FIELD\r
719                && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){\r
720                 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);\r
721             }\r
722             if(MB_FIELD\r
723                && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])\r
724                && i >= scan8[0]+8){\r
725                 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.\r
726                 SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);\r
727             }\r
728         }\r
729 #undef SET_DIAG_MV\r
730     }\r
731 \r
732     if(topright_ref != PART_NOT_AVAILABLE){\r
733         *C= h->mv_cache[list][ i - 8 + part_width ];\r
734         return topright_ref;\r
735     }else{\r
736         tprintf(s->avctx, "topright MV not available\n");\r
737 \r
738         *C= h->mv_cache[list][ i - 8 - 1 ];\r
739         return h->ref_cache[list][ i - 8 - 1 ];\r
740     }\r
741 }\r
742 \r
743 /**\r
744  * gets the predicted MV.\r
745  * @param n the block index\r
746  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)\r
747  * @param mx the x component of the predicted motion vector\r
748  * @param my the y component of the predicted motion vector\r
749  */\r
750 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){\r
751     const int index8= scan8[n];\r
752     const int top_ref=      h->ref_cache[list][ index8 - 8 ];\r
753     const int left_ref=     h->ref_cache[list][ index8 - 1 ];\r
754     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];\r
755     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];\r
756     const int16_t * C;\r
757     int diagonal_ref, match_count;\r
758 \r
759     assert(part_width==1 || part_width==2 || part_width==4);\r
760 \r
761 /* mv_cache\r
762   B . . A T T T T\r
763   U . . L . . , .\r
764   U . . L . . . .\r
765   U . . L . . , .\r
766   . . . L . . . .\r
767 */\r
768 \r
769     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);\r
770     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);\r
771     tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);\r
772     if(match_count > 1){ //most common\r
773         *mx= mid_pred(A[0], B[0], C[0]);\r
774         *my= mid_pred(A[1], B[1], C[1]);\r
775     }else if(match_count==1){\r
776         if(left_ref==ref){\r
777             *mx= A[0];\r
778             *my= A[1];\r
779         }else if(top_ref==ref){\r
780             *mx= B[0];\r
781             *my= B[1];\r
782         }else{\r
783             *mx= C[0];\r
784             *my= C[1];\r
785         }\r
786     }else{\r
787         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){\r
788             *mx= A[0];\r
789             *my= A[1];\r
790         }else{\r
791             *mx= mid_pred(A[0], B[0], C[0]);\r
792             *my= mid_pred(A[1], B[1], C[1]);\r
793         }\r
794     }\r
795 \r
796     tprintf(h->s.avctx, "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1],                    diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list);\r
797 }\r
798 \r
799 /**\r
800  * gets the directionally predicted 16x8 MV.\r
801  * @param n the block index\r
802  * @param mx the x component of the predicted motion vector\r
803  * @param my the y component of the predicted motion vector\r
804  */\r
805 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){\r
806     if(n==0){\r
807         const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];\r
808         const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];\r
809 \r
810         tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list);\r
811 \r
812         if(top_ref == ref){\r
813             *mx= B[0];\r
814             *my= B[1];\r
815             return;\r
816         }\r
817     }else{\r
818         const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];\r
819         const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];\r
820 \r
821         tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);\r
822 \r
823         if(left_ref == ref){\r
824             *mx= A[0];\r
825             *my= A[1];\r
826             return;\r
827         }\r
828     }\r
829 \r
830     //RARE\r
831     pred_motion(h, n, 4, list, ref, mx, my);\r
832 }\r
833 \r
834 /**\r
835  * gets the directionally predicted 8x16 MV.\r
836  * @param n the block index\r
837  * @param mx the x component of the predicted motion vector\r
838  * @param my the y component of the predicted motion vector\r
839  */\r
840 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){\r
841     if(n==0){\r
842         const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];\r
843         const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];\r
844 \r
845         tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);\r
846 \r
847         if(left_ref == ref){\r
848             *mx= A[0];\r
849             *my= A[1];\r
850             return;\r
851         }\r
852     }else{\r
853         const int16_t * C;\r
854         int diagonal_ref;\r
855 \r
856         diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);\r
857 \r
858         tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list);\r
859 \r
860         if(diagonal_ref == ref){\r
861             *mx= C[0];\r
862             *my= C[1];\r
863             return;\r
864         }\r
865     }\r
866 \r
867     //RARE\r
868     pred_motion(h, n, 2, list, ref, mx, my);\r
869 }\r
870 \r
871 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){\r
872     const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];\r
873     const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];\r
874 \r
875     tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);\r
876 \r
877     if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE\r
878        || !( top_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ])\r
879        || !(left_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ])){\r
880 \r
881         *mx = *my = 0;\r
882         return;\r
883     }\r
884 \r
885     pred_motion(h, 0, 4, 0, 0, mx, my);\r
886 \r
887     return;\r
888 }\r
889 \r
890 static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){\r
891     int poc0 = h->ref_list[0][i].poc;\r
892     int td = av_clip(poc1 - poc0, -128, 127);\r
893     if(td == 0 || h->ref_list[0][i].long_ref){\r
894         return 256;\r
895     }else{\r
896         int tb = av_clip(poc - poc0, -128, 127);\r
897         int tx = (16384 + (FFABS(td) >> 1)) / td;\r
898         return av_clip((tb*tx + 32) >> 6, -1024, 1023);\r
899     }\r
900 }\r
901 \r
902 static inline void direct_dist_scale_factor(H264Context * const h){\r
903     MpegEncContext * const s = &h->s;\r
904     const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];\r
905     const int poc1 = h->ref_list[1][0].poc;\r
906     int i, field;\r
907     for(field=0; field<2; field++){\r
908         const int poc  = h->s.current_picture_ptr->field_poc[field];\r
909         const int poc1 = h->ref_list[1][0].field_poc[field];\r
910         for(i=0; i < 2*h->ref_count[0]; i++)\r
911             h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16);\r
912     }\r
913 \r
914     for(i=0; i<h->ref_count[0]; i++){\r
915         h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);\r
916     }\r
917 }\r
918 \r
919 static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){\r
920     MpegEncContext * const s = &h->s;\r
921     Picture * const ref1 = &h->ref_list[1][0];\r
922     int j, old_ref, rfield;\r
923     int start= mbafi ? 16                      : 0;\r
924     int end  = mbafi ? 16+2*h->ref_count[list] : h->ref_count[list];\r
925     int interl= mbafi || s->picture_structure != PICT_FRAME;\r
926 \r
927     /* bogus; fills in for missing frames */\r
928     memset(map[list], 0, sizeof(map[list]));\r
929 \r
930     for(rfield=0; rfield<2; rfield++){\r
931         for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){\r
932             int poc = ref1->ref_poc[colfield][list][old_ref];\r
933 \r
934             if     (!interl)\r
935                 poc |= 3;\r
936             else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed\r
937                 poc= (poc&~3) + rfield + 1;\r
938 \r
939             for(j=start; j<end; j++){\r
940                 if(4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3) == poc){\r
941                     int cur_ref= mbafi ? (j-16)^field : j;\r
942                     map[list][2*old_ref + (rfield^field) + 16] = cur_ref;\r
943                     if(rfield == field)\r
944                         map[list][old_ref] = cur_ref;\r
945                     break;\r
946                 }\r
947             }\r
948         }\r
949     }\r
950 }\r
951 \r
952 static inline void direct_ref_list_init(H264Context * const h){\r
953     MpegEncContext * const s = &h->s;\r
954     Picture * const ref1 = &h->ref_list[1][0];\r
955     Picture * const cur = s->current_picture_ptr;\r
956     int list, j, field;\r
957     int sidx= (s->picture_structure&1)^1;\r
958     int ref1sidx= (ref1->reference&1)^1;\r
959 \r
960     for(list=0; list<2; list++){\r
961         cur->ref_count[sidx][list] = h->ref_count[list];\r
962         for(j=0; j<h->ref_count[list]; j++)\r
963             cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3);\r
964     }\r
965 \r
966     if(s->picture_structure == PICT_FRAME){\r
967         memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));\r
968         memcpy(cur->ref_poc  [1], cur->ref_poc  [0], sizeof(cur->ref_poc  [0]));\r
969     }\r
970 \r
971     cur->mbaff= FRAME_MBAFF;\r
972 \r
973     if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)\r
974         return;\r
975 \r
976     for(list=0; list<2; list++){\r
977         fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);\r
978         for(field=0; field<2; field++)\r
979             fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);\r
980     }\r
981 }\r
982 \r
983 static inline void pred_direct_motion(H264Context * const h, int *mb_type){\r
984     MpegEncContext * const s = &h->s;\r
985     int b8_stride = h->b8_stride;\r
986     int b4_stride = h->b_stride;\r
987     int mb_xy = h->mb_xy;\r
988     int mb_type_col[2];\r
989     const int16_t (*l1mv0)[2], (*l1mv1)[2];\r
990     const int8_t *l1ref0, *l1ref1;\r
991     const int is_b8x8 = IS_8X8(*mb_type);\r
992     unsigned int sub_mb_type;\r
993     int i8, i4;\r
994 \r
995 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)\r
996 \r
997     if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL\r
998         if(!IS_INTERLACED(*mb_type)){                    //     AFR/FR    -> AFL/FL\r
999             int cur_poc = s->current_picture_ptr->poc;\r
1000             int *col_poc = h->ref_list[1]->field_poc;\r
1001             int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);\r
1002             mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;\r
1003             b8_stride = 0;\r
1004         }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity\r
1005             int fieldoff= 2*(h->ref_list[1][0].reference)-3;\r
1006             mb_xy += s->mb_stride*fieldoff;\r
1007         }\r
1008         goto single_col;\r
1009     }else{                                               // AFL/AFR/FR/FL -> AFR/FR\r
1010         if(IS_INTERLACED(*mb_type)){                     // AFL       /FL -> AFR/FR\r
1011             mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;\r
1012             mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];\r
1013             mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];\r
1014             b8_stride *= 3;\r
1015             b4_stride *= 6;\r
1016             //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag\r
1017             if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)\r
1018                 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)\r
1019                 && !is_b8x8){\r
1020                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */\r
1021                 *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */\r
1022             }else{\r
1023                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */\r
1024                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\r
1025             }\r
1026         }else{                                           //     AFR/FR    -> AFR/FR\r
1027 single_col:\r
1028             mb_type_col[0] =\r
1029             mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];\r
1030             if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){\r
1031                 /* FIXME save sub mb types from previous frames (or derive from MVs)\r
1032                 * so we know exactly what block size to use */\r
1033                 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */\r
1034                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\r
1035             }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){\r
1036                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */\r
1037                 *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */\r
1038             }else{\r
1039                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */\r
1040                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\r
1041             }\r
1042         }\r
1043     }\r
1044 \r
1045     l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];\r
1046     l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];\r
1047     l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];\r
1048     l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];\r
1049     if(!b8_stride){\r
1050         if(s->mb_y&1){\r
1051             l1ref0 += h->b8_stride;\r
1052             l1ref1 += h->b8_stride;\r
1053             l1mv0  +=  2*b4_stride;\r
1054             l1mv1  +=  2*b4_stride;\r
1055         }\r
1056     }\r
1057 \r
1058     if(h->direct_spatial_mv_pred){\r
1059         int ref[2];\r
1060         int mv[2][2];\r
1061         int list;\r
1062 \r
1063         /* FIXME interlacing + spatial direct uses wrong colocated block positions */\r
1064 \r
1065         /* ref = min(neighbors) */\r
1066         for(list=0; list<2; list++){\r
1067             int refa = h->ref_cache[list][scan8[0] - 1];\r
1068             int refb = h->ref_cache[list][scan8[0] - 8];\r
1069             int refc = h->ref_cache[list][scan8[0] - 8 + 4];\r
1070             if(refc == PART_NOT_AVAILABLE)\r
1071                 refc = h->ref_cache[list][scan8[0] - 8 - 1];\r
1072             ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);\r
1073             if(ref[list] < 0)\r
1074                 ref[list] = -1;\r
1075         }\r
1076 \r
1077         if(ref[0] < 0 && ref[1] < 0){\r
1078             ref[0] = ref[1] = 0;\r
1079             mv[0][0] = mv[0][1] =\r
1080             mv[1][0] = mv[1][1] = 0;\r
1081         }else{\r
1082             for(list=0; list<2; list++){\r
1083                 if(ref[list] >= 0)\r
1084                     pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);\r
1085                 else\r
1086                     mv[list][0] = mv[list][1] = 0;\r
1087             }\r
1088         }\r
1089 \r
1090         if(ref[1] < 0){\r
1091             if(!is_b8x8)\r
1092                 *mb_type &= ~MB_TYPE_L1;\r
1093             sub_mb_type &= ~MB_TYPE_L1;\r
1094         }else if(ref[0] < 0){\r
1095             if(!is_b8x8)\r
1096                 *mb_type &= ~MB_TYPE_L0;\r
1097             sub_mb_type &= ~MB_TYPE_L0;\r
1098         }\r
1099 \r
1100         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){\r
1101             for(i8=0; i8<4; i8++){\r
1102                 int x8 = i8&1;\r
1103                 int y8 = i8>>1;\r
1104                 int xy8 = x8+y8*b8_stride;\r
1105                 int xy4 = 3*x8+y8*b4_stride;\r
1106                 int a=0, b=0;\r
1107 \r
1108                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\r
1109                     continue;\r
1110                 h->sub_mb_type[i8] = sub_mb_type;\r
1111 \r
1112                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);\r
1113                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);\r
1114                 if(!IS_INTRA(mb_type_col[y8])\r
1115                    && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)\r
1116                        || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){\r
1117                     if(ref[0] > 0)\r
1118                         a= pack16to32(mv[0][0],mv[0][1]);\r
1119                     if(ref[1] > 0)\r
1120                         b= pack16to32(mv[1][0],mv[1][1]);\r
1121                 }else{\r
1122                     a= pack16to32(mv[0][0],mv[0][1]);\r
1123                     b= pack16to32(mv[1][0],mv[1][1]);\r
1124                 }\r
1125                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);\r
1126                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);\r
1127             }\r
1128         }else if(IS_16X16(*mb_type)){\r
1129             int a=0, b=0;\r
1130 \r
1131             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);\r
1132             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);\r
1133             if(!IS_INTRA(mb_type_col[0])\r
1134                && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)\r
1135                    || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1\r
1136                        && (h->x264_build>33 || !h->x264_build)))){\r
1137                 if(ref[0] > 0)\r
1138                     a= pack16to32(mv[0][0],mv[0][1]);\r
1139                 if(ref[1] > 0)\r
1140                     b= pack16to32(mv[1][0],mv[1][1]);\r
1141             }else{\r
1142                 a= pack16to32(mv[0][0],mv[0][1]);\r
1143                 b= pack16to32(mv[1][0],mv[1][1]);\r
1144             }\r
1145             fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);\r
1146             fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);\r
1147         }else{\r
1148             for(i8=0; i8<4; i8++){\r
1149                 const int x8 = i8&1;\r
1150                 const int y8 = i8>>1;\r
1151 \r
1152                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\r
1153                     continue;\r
1154                 h->sub_mb_type[i8] = sub_mb_type;\r
1155 \r
1156                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);\r
1157                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);\r
1158                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);\r
1159                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);\r
1160 \r
1161                 /* col_zero_flag */\r
1162                 if(!IS_INTRA(mb_type_col[0]) && (   l1ref0[x8 + y8*b8_stride] == 0\r
1163                                               || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0\r
1164                                                   && (h->x264_build>33 || !h->x264_build)))){\r
1165                     const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;\r
1166                     if(IS_SUB_8X8(sub_mb_type)){\r
1167                         const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];\r
1168                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){\r
1169                             if(ref[0] == 0)\r
1170                                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1171                             if(ref[1] == 0)\r
1172                                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1173                         }\r
1174                     }else\r
1175                     for(i4=0; i4<4; i4++){\r
1176                         const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];\r
1177                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){\r
1178                             if(ref[0] == 0)\r
1179                                 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;\r
1180                             if(ref[1] == 0)\r
1181                                 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;\r
1182                         }\r
1183                     }\r
1184                 }\r
1185             }\r
1186         }\r
1187     }else{ /* direct temporal mv pred */\r
1188         const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};\r
1189         const int *dist_scale_factor = h->dist_scale_factor;\r
1190         int ref_offset= 0;\r
1191 \r
1192         if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){\r
1193             map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];\r
1194             map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];\r
1195             dist_scale_factor   =h->dist_scale_factor_field[s->mb_y&1];\r
1196         }\r
1197         if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))\r
1198             ref_offset += 16;\r
1199 \r
1200         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){\r
1201             /* FIXME assumes direct_8x8_inference == 1 */\r
1202             int y_shift  = 2*!IS_INTERLACED(*mb_type);\r
1203 \r
1204             for(i8=0; i8<4; i8++){\r
1205                 const int x8 = i8&1;\r
1206                 const int y8 = i8>>1;\r
1207                 int ref0, scale;\r
1208                 const int16_t (*l1mv)[2]= l1mv0;\r
1209 \r
1210                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\r
1211                     continue;\r
1212                 h->sub_mb_type[i8] = sub_mb_type;\r
1213 \r
1214                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);\r
1215                 if(IS_INTRA(mb_type_col[y8])){\r
1216                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);\r
1217                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1218                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1219                     continue;\r
1220                 }\r
1221 \r
1222                 ref0 = l1ref0[x8 + y8*b8_stride];\r
1223                 if(ref0 >= 0)\r
1224                     ref0 = map_col_to_list0[0][ref0 + ref_offset];\r
1225                 else{\r
1226                     ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];\r
1227                     l1mv= l1mv1;\r
1228                 }\r
1229                 scale = dist_scale_factor[ref0];\r
1230                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);\r
1231 \r
1232                 {\r
1233                     const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride];\r
1234                     int my_col = (mv_col[1]<<y_shift)/2;\r
1235                     int mx = (scale * mv_col[0] + 128) >> 8;\r
1236                     int my = (scale * my_col + 128) >> 8;\r
1237                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);\r
1238                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);\r
1239                 }\r
1240             }\r
1241             return;\r
1242         }\r
1243 \r
1244         /* one-to-one mv scaling */\r
1245 \r
1246         if(IS_16X16(*mb_type)){\r
1247             int ref, mv0, mv1;\r
1248 \r
1249             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);\r
1250             if(IS_INTRA(mb_type_col[0])){\r
1251                 ref=mv0=mv1=0;\r
1252             }else{\r
1253                 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]\r
1254                                                 : map_col_to_list0[1][l1ref1[0] + ref_offset];\r
1255                 const int scale = dist_scale_factor[ref0];\r
1256                 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];\r
1257                 int mv_l0[2];\r
1258                 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;\r
1259                 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;\r
1260                 ref= ref0;\r
1261                 mv0= pack16to32(mv_l0[0],mv_l0[1]);\r
1262                 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);\r
1263             }\r
1264             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);\r
1265             fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);\r
1266             fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);\r
1267         }else{\r
1268             for(i8=0; i8<4; i8++){\r
1269                 const int x8 = i8&1;\r
1270                 const int y8 = i8>>1;\r
1271                 int ref0, scale;\r
1272                 const int16_t (*l1mv)[2]= l1mv0;\r
1273 \r
1274                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\r
1275                     continue;\r
1276                 h->sub_mb_type[i8] = sub_mb_type;\r
1277                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);\r
1278                 if(IS_INTRA(mb_type_col[0])){\r
1279                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);\r
1280                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1281                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\r
1282                     continue;\r
1283                 }\r
1284 \r
1285                 ref0 = l1ref0[x8 + y8*b8_stride] + ref_offset;\r
1286                 if(ref0 >= 0)\r
1287                     ref0 = map_col_to_list0[0][ref0];\r
1288                 else{\r
1289                     ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];\r
1290                     l1mv= l1mv1;\r
1291                 }\r
1292                 scale = dist_scale_factor[ref0];\r
1293 \r
1294                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);\r
1295                 if(IS_SUB_8X8(sub_mb_type)){\r
1296                     const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];\r
1297                     int mx = (scale * mv_col[0] + 128) >> 8;\r
1298                     int my = (scale * mv_col[1] + 128) >> 8;\r
1299                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);\r
1300                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);\r
1301                 }else\r
1302                 for(i4=0; i4<4; i4++){\r
1303                     const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];\r
1304                     int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];\r
1305                     mv_l0[0] = (scale * mv_col[0] + 128) >> 8;\r
1306                     mv_l0[1] = (scale * mv_col[1] + 128) >> 8;\r
1307                     *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =\r
1308                         pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);\r
1309                 }\r
1310             }\r
1311         }\r
1312     }\r
1313 }\r
1314 \r
1315 static inline void write_back_motion(H264Context *h, int mb_type){\r
1316     MpegEncContext * const s = &h->s;\r
1317     const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;\r
1318     const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;\r
1319     int list;\r
1320 \r
1321     if(!USES_LIST(mb_type, 0))\r
1322         fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);\r
1323 \r
1324     for(list=0; list<h->list_count; list++){\r
1325         int y;\r
1326         if(!USES_LIST(mb_type, list))\r
1327             continue;\r
1328 \r
1329         for(y=0; y<4; y++){\r
1330             *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y];\r
1331             *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y];\r
1332         }\r
1333         if( h->pps.cabac ) {\r
1334             if(IS_SKIP(mb_type))\r
1335                 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4);\r
1336             else\r
1337             for(y=0; y<4; y++){\r
1338                 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];\r
1339                 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];\r
1340             }\r
1341         }\r
1342 \r
1343         {\r
1344             int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];\r
1345             ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];\r
1346             ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];\r
1347             ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];\r
1348             ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];\r
1349         }\r
1350     }\r
1351 \r
1352     if(h->slice_type_nos == FF_B_TYPE && h->pps.cabac){\r
1353         if(IS_8X8(mb_type)){\r
1354             uint8_t *direct_table = &h->direct_table[b8_xy];\r
1355             direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;\r
1356             direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;\r
1357             direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;\r
1358         }\r
1359     }\r
1360 }\r
1361 \r
1362 /**\r
1363  * Decodes a network abstraction layer unit.\r
1364  * @param consumed is the number of bytes used as input\r
1365  * @param length is the length of the array\r
1366  * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?\r
1367  * @returns decoded bytes, might be src+1 if no escapes\r
1368  */\r
1369 static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){\r
1370     int i, si, di;\r
1371     uint8_t *dst;\r
1372     int bufidx;\r
1373 \r
1374 //    src[0]&0x80;                //forbidden bit\r
1375     h->nal_ref_idc= src[0]>>5;\r
1376     h->nal_unit_type= src[0]&0x1F;\r
1377 \r
1378     src++; length--;\r
1379 #if 0\r
1380     for(i=0; i<length; i++)\r
1381         printf("%2X ", src[i]);\r
1382 #endif\r
1383 \r
1384 #if HAVE_FAST_UNALIGNED\r
1385 # if HAVE_FAST_64BIT\r
1386 #   define RS 7\r
1387     for(i=0; i+1<length; i+=9){\r
1388         if(!((~*(uint64_t*)(src+i) & (*(uint64_t*)(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))\r
1389 # else\r
1390 #   define RS 3\r
1391     for(i=0; i+1<length; i+=5){\r
1392         if(!((~*(uint32_t*)(src+i) & (*(uint32_t*)(src+i) - 0x01000101U)) & 0x80008080U))\r
1393 # endif\r
1394             continue;\r
1395         if(i>0 && !src[i]) i--;\r
1396         while(src[i]) i++;\r
1397 #else\r
1398 #   define RS 0\r
1399     for(i=0; i+1<length; i+=2){\r
1400         if(src[i]) continue;\r
1401         if(i>0 && src[i-1]==0) i--;\r
1402 #endif\r
1403         if(i+2<length && src[i+1]==0 && src[i+2]<=3){\r
1404             if(src[i+2]!=3){\r
1405                 /* startcode, so we must be past the end */\r
1406                 length=i;\r
1407             }\r
1408             break;\r
1409         }\r
1410         i-= RS;\r
1411     }\r
1412 \r
1413     if(i>=length-1){ //no escaped 0\r
1414         *dst_length= length;\r
1415         *consumed= length+1; //+1 for the header\r
1416         return src;\r
1417     }\r
1418 \r
1419     bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data\r
1420     h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);\r
1421     dst= h->rbsp_buffer[bufidx];\r
1422 \r
1423     if (dst == NULL){\r
1424         return NULL;\r
1425     }\r
1426 \r
1427 //printf("decoding esc\n");\r
1428     memcpy(dst, src, i);\r
1429     si=di=i;\r
1430     while(si+2<length){\r
1431         //remove escapes (very rare 1:2^22)\r
1432         if(src[si+2]>3){\r
1433             dst[di++]= src[si++];\r
1434             dst[di++]= src[si++];\r
1435         }else if(src[si]==0 && src[si+1]==0){\r
1436             if(src[si+2]==3){ //escape\r
1437                 dst[di++]= 0;\r
1438                 dst[di++]= 0;\r
1439                 si+=3;\r
1440                 continue;\r
1441             }else //next start code\r
1442                 goto nsc;\r
1443         }\r
1444 \r
1445         dst[di++]= src[si++];\r
1446     }\r
1447     while(si<length)\r
1448         dst[di++]= src[si++];\r
1449 nsc:\r
1450 \r
1451     memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);\r
1452 \r
1453     *dst_length= di;\r
1454     *consumed= si + 1;//+1 for the header\r
1455 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)\r
1456     return dst;\r
1457 }\r
1458 \r
1459 /**\r
1460  * identifies the exact end of the bitstream\r
1461  * @return the length of the trailing, or 0 if damaged\r
1462  */\r
1463 static int decode_rbsp_trailing(H264Context *h, const uint8_t *src){\r
1464     int v= *src;\r
1465     int r;\r
1466 \r
1467     tprintf(h->s.avctx, "rbsp trailing %X\n", v);\r
1468 \r
1469     for(r=1; r<9; r++){\r
1470         if(v&1) return r;\r
1471         v>>=1;\r
1472     }\r
1473     return 0;\r
1474 }\r
1475 \r
1476 /**\r
1477  * IDCT transforms the 16 dc values and dequantizes them.\r
1478  * @param qp quantization parameter\r
1479  */\r
1480 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){\r
1481 #define stride 16\r
1482     int i;\r
1483     int temp[16]; //FIXME check if this is a good idea\r
1484     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};\r
1485     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};\r
1486 \r
1487 //memset(block, 64, 2*256);\r
1488 //return;\r
1489     for(i=0; i<4; i++){\r
1490         const int offset= y_offset[i];\r
1491         const int z0= block[offset+stride*0] + block[offset+stride*4];\r
1492         const int z1= block[offset+stride*0] - block[offset+stride*4];\r
1493         const int z2= block[offset+stride*1] - block[offset+stride*5];\r
1494         const int z3= block[offset+stride*1] + block[offset+stride*5];\r
1495 \r
1496         temp[4*i+0]= z0+z3;\r
1497         temp[4*i+1]= z1+z2;\r
1498         temp[4*i+2]= z1-z2;\r
1499         temp[4*i+3]= z0-z3;\r
1500     }\r
1501 \r
1502     for(i=0; i<4; i++){\r
1503         const int offset= x_offset[i];\r
1504         const int z0= temp[4*0+i] + temp[4*2+i];\r
1505         const int z1= temp[4*0+i] - temp[4*2+i];\r
1506         const int z2= temp[4*1+i] - temp[4*3+i];\r
1507         const int z3= temp[4*1+i] + temp[4*3+i];\r
1508 \r
1509         block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual\r
1510         block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));\r
1511         block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));\r
1512         block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));\r
1513     }\r
1514 }\r
1515 \r
1516 #if 0\r
1517 /**\r
1518  * DCT transforms the 16 dc values.\r
1519  * @param qp quantization parameter ??? FIXME\r
1520  */\r
1521 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){\r
1522 //    const int qmul= dequant_coeff[qp][0];\r
1523     int i;\r
1524     int temp[16]; //FIXME check if this is a good idea\r
1525     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};\r
1526     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};\r
1527 \r
1528     for(i=0; i<4; i++){\r
1529         const int offset= y_offset[i];\r
1530         const int z0= block[offset+stride*0] + block[offset+stride*4];\r
1531         const int z1= block[offset+stride*0] - block[offset+stride*4];\r
1532         const int z2= block[offset+stride*1] - block[offset+stride*5];\r
1533         const int z3= block[offset+stride*1] + block[offset+stride*5];\r
1534 \r
1535         temp[4*i+0]= z0+z3;\r
1536         temp[4*i+1]= z1+z2;\r
1537         temp[4*i+2]= z1-z2;\r
1538         temp[4*i+3]= z0-z3;\r
1539     }\r
1540 \r
1541     for(i=0; i<4; i++){\r
1542         const int offset= x_offset[i];\r
1543         const int z0= temp[4*0+i] + temp[4*2+i];\r
1544         const int z1= temp[4*0+i] - temp[4*2+i];\r
1545         const int z2= temp[4*1+i] - temp[4*3+i];\r
1546         const int z3= temp[4*1+i] + temp[4*3+i];\r
1547 \r
1548         block[stride*0 +offset]= (z0 + z3)>>1;\r
1549         block[stride*2 +offset]= (z1 + z2)>>1;\r
1550         block[stride*8 +offset]= (z1 - z2)>>1;\r
1551         block[stride*10+offset]= (z0 - z3)>>1;\r
1552     }\r
1553 }\r
1554 #endif\r
1555 \r
1556 #undef xStride\r
1557 #undef stride\r
1558 \r
1559 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){\r
1560     const int stride= 16*2;\r
1561     const int xStride= 16;\r
1562     int a,b,c,d,e;\r
1563 \r
1564     a= block[stride*0 + xStride*0];\r
1565     b= block[stride*0 + xStride*1];\r
1566     c= block[stride*1 + xStride*0];\r
1567     d= block[stride*1 + xStride*1];\r
1568 \r
1569     e= a-b;\r
1570     a= a+b;\r
1571     b= c-d;\r
1572     c= c+d;\r
1573 \r
1574     block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;\r
1575     block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;\r
1576     block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;\r
1577     block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;\r
1578 }\r
1579 \r
1580 #if 0\r
1581 static void chroma_dc_dct_c(DCTELEM *block){\r
1582     const int stride= 16*2;\r
1583     const int xStride= 16;\r
1584     int a,b,c,d,e;\r
1585 \r
1586     a= block[stride*0 + xStride*0];\r
1587     b= block[stride*0 + xStride*1];\r
1588     c= block[stride*1 + xStride*0];\r
1589     d= block[stride*1 + xStride*1];\r
1590 \r
1591     e= a-b;\r
1592     a= a+b;\r
1593     b= c-d;\r
1594     c= c+d;\r
1595 \r
1596     block[stride*0 + xStride*0]= (a+c);\r
1597     block[stride*0 + xStride*1]= (e+b);\r
1598     block[stride*1 + xStride*0]= (a-c);\r
1599     block[stride*1 + xStride*1]= (e-b);\r
1600 }\r
1601 #endif\r
1602 \r
1603 /**\r
1604  * gets the chroma qp.\r
1605  */\r
1606 static inline int get_chroma_qp(H264Context *h, int t, int qscale){\r
1607     return h->pps.chroma_qp_table[t][qscale];\r
1608 }\r
1609 \r
1610 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,\r
1611                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\r
1612                            int src_x_offset, int src_y_offset,\r
1613                            qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){\r
1614     MpegEncContext * const s = &h->s;\r
1615     const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;\r
1616     int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;\r
1617     const int luma_xy= (mx&3) + ((my&3)<<2);\r
1618     uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;\r
1619     uint8_t * src_cb, * src_cr;\r
1620     int extra_width= h->emu_edge_width;\r
1621     int extra_height= h->emu_edge_height;\r
1622     int emu=0;\r
1623     const int full_mx= mx>>2;\r
1624     const int full_my= my>>2;\r
1625     const int pic_width  = 16*s->mb_width;\r
1626     const int pic_height = 16*s->mb_height >> MB_FIELD;\r
1627 \r
1628     if(mx&7) extra_width -= 3;\r
1629     if(my&7) extra_height -= 3;\r
1630 \r
1631     if(   full_mx < 0-extra_width\r
1632        || full_my < 0-extra_height\r
1633        || full_mx + 16/*FIXME*/ > pic_width + extra_width\r
1634        || full_my + 16/*FIXME*/ > pic_height + extra_height){\r
1635         ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);\r
1636             src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;\r
1637         emu=1;\r
1638     }\r
1639 \r
1640     qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?\r
1641     if(!square){\r
1642         qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);\r
1643     }\r
1644 \r
1645     if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;\r
1646 \r
1647     if(MB_FIELD){\r
1648         // chroma offset when predicting from a field of opposite parity\r
1649         my += 2 * ((s->mb_y & 1) - (pic->reference - 1));\r
1650         emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);\r
1651     }\r
1652     src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;\r
1653     src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;\r
1654 \r
1655     if(emu){\r
1656         ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);\r
1657             src_cb= s->edge_emu_buffer;\r
1658     }\r
1659     chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);\r
1660 \r
1661     if(emu){\r
1662         ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);\r
1663             src_cr= s->edge_emu_buffer;\r
1664     }\r
1665     chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);\r
1666 }\r
1667 \r
1668 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,\r
1669                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\r
1670                            int x_offset, int y_offset,\r
1671                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,\r
1672                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,\r
1673                            int list0, int list1){\r
1674     MpegEncContext * const s = &h->s;\r
1675     qpel_mc_func *qpix_op=  qpix_put;\r
1676     h264_chroma_mc_func chroma_op= chroma_put;\r
1677 \r
1678     dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;\r
1679     dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;\r
1680     dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;\r
1681     x_offset += 8*s->mb_x;\r
1682     y_offset += 8*(s->mb_y >> MB_FIELD);\r
1683 \r
1684     if(list0){\r
1685         Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];\r
1686         mc_dir_part(h, ref, n, square, chroma_height, delta, 0,\r
1687                            dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1688                            qpix_op, chroma_op);\r
1689 \r
1690         qpix_op=  qpix_avg;\r
1691         chroma_op= chroma_avg;\r
1692     }\r
1693 \r
1694     if(list1){\r
1695         Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];\r
1696         mc_dir_part(h, ref, n, square, chroma_height, delta, 1,\r
1697                            dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1698                            qpix_op, chroma_op);\r
1699     }\r
1700 }\r
1701 \r
1702 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,\r
1703                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\r
1704                            int x_offset, int y_offset,\r
1705                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,\r
1706                            h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,\r
1707                            h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,\r
1708                            int list0, int list1){\r
1709     MpegEncContext * const s = &h->s;\r
1710 \r
1711     dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;\r
1712     dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;\r
1713     dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;\r
1714     x_offset += 8*s->mb_x;\r
1715     y_offset += 8*(s->mb_y >> MB_FIELD);\r
1716 \r
1717     if(list0 && list1){\r
1718         /* don't optimize for luma-only case, since B-frames usually\r
1719          * use implicit weights => chroma too. */\r
1720         uint8_t *tmp_cb = s->obmc_scratchpad;\r
1721         uint8_t *tmp_cr = s->obmc_scratchpad + 8;\r
1722         uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;\r
1723         int refn0 = h->ref_cache[0][ scan8[n] ];\r
1724         int refn1 = h->ref_cache[1][ scan8[n] ];\r
1725 \r
1726         mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,\r
1727                     dest_y, dest_cb, dest_cr,\r
1728                     x_offset, y_offset, qpix_put, chroma_put);\r
1729         mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,\r
1730                     tmp_y, tmp_cb, tmp_cr,\r
1731                     x_offset, y_offset, qpix_put, chroma_put);\r
1732 \r
1733         if(h->use_weight == 2){\r
1734             int weight0 = h->implicit_weight[refn0][refn1];\r
1735             int weight1 = 64 - weight0;\r
1736             luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);\r
1737             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);\r
1738             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);\r
1739         }else{\r
1740             luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,\r
1741                             h->luma_weight[0][refn0], h->luma_weight[1][refn1],\r
1742                             h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);\r
1743             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,\r
1744                             h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],\r
1745                             h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);\r
1746             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,\r
1747                             h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],\r
1748                             h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);\r
1749         }\r
1750     }else{\r
1751         int list = list1 ? 1 : 0;\r
1752         int refn = h->ref_cache[list][ scan8[n] ];\r
1753         Picture *ref= &h->ref_list[list][refn];\r
1754         mc_dir_part(h, ref, n, square, chroma_height, delta, list,\r
1755                     dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1756                     qpix_put, chroma_put);\r
1757 \r
1758         luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,\r
1759                        h->luma_weight[list][refn], h->luma_offset[list][refn]);\r
1760         if(h->use_weight_chroma){\r
1761             chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,\r
1762                              h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);\r
1763             chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,\r
1764                              h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);\r
1765         }\r
1766     }\r
1767 }\r
1768 \r
1769 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,\r
1770                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\r
1771                            int x_offset, int y_offset,\r
1772                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,\r
1773                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,\r
1774                            h264_weight_func *weight_op, h264_biweight_func *weight_avg,\r
1775                            int list0, int list1){\r
1776     if((h->use_weight==2 && list0 && list1\r
1777         && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))\r
1778        || h->use_weight==1)\r
1779         mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,\r
1780                          x_offset, y_offset, qpix_put, chroma_put,\r
1781                          weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);\r
1782     else\r
1783         mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,\r
1784                     x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);\r
1785 }\r
1786 \r
1787 static inline void prefetch_motion(H264Context *h, int list){\r
1788     /* fetch pixels for estimated mv 4 macroblocks ahead\r
1789      * optimized for 64byte cache lines */\r
1790     MpegEncContext * const s = &h->s;\r
1791     const int refn = h->ref_cache[list][scan8[0]];\r
1792     if(refn >= 0){\r
1793         const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;\r
1794         const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;\r
1795         uint8_t **src= h->ref_list[list][refn].data;\r
1796         int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;\r
1797         s->dsp.prefetch(src[0]+off, s->linesize, 4);\r
1798         off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;\r
1799         s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);\r
1800     }\r
1801 }\r
1802 \r
1803 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\r
1804                       qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),\r
1805                       qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),\r
1806                       h264_weight_func *weight_op, h264_biweight_func *weight_avg){\r
1807     MpegEncContext * const s = &h->s;\r
1808     const int mb_xy= h->mb_xy;\r
1809     const int mb_type= s->current_picture.mb_type[mb_xy];\r
1810 \r
1811     assert(IS_INTER(mb_type));\r
1812 \r
1813     prefetch_motion(h, 0);\r
1814 \r
1815     if(IS_16X16(mb_type)){\r
1816         mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,\r
1817                 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],\r
1818                 &weight_op[0], &weight_avg[0],\r
1819                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\r
1820     }else if(IS_16X8(mb_type)){\r
1821         mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,\r
1822                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],\r
1823                 &weight_op[1], &weight_avg[1],\r
1824                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\r
1825         mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,\r
1826                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],\r
1827                 &weight_op[1], &weight_avg[1],\r
1828                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));\r
1829     }else if(IS_8X16(mb_type)){\r
1830         mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,\r
1831                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\r
1832                 &weight_op[2], &weight_avg[2],\r
1833                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\r
1834         mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,\r
1835                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\r
1836                 &weight_op[2], &weight_avg[2],\r
1837                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));\r
1838     }else{\r
1839         int i;\r
1840 \r
1841         assert(IS_8X8(mb_type));\r
1842 \r
1843         for(i=0; i<4; i++){\r
1844             const int sub_mb_type= h->sub_mb_type[i];\r
1845             const int n= 4*i;\r
1846             int x_offset= (i&1)<<2;\r
1847             int y_offset= (i&2)<<1;\r
1848 \r
1849             if(IS_SUB_8X8(sub_mb_type)){\r
1850                 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1851                     qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\r
1852                     &weight_op[3], &weight_avg[3],\r
1853                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1854             }else if(IS_SUB_8X4(sub_mb_type)){\r
1855                 mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1856                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],\r
1857                     &weight_op[4], &weight_avg[4],\r
1858                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1859                 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,\r
1860                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],\r
1861                     &weight_op[4], &weight_avg[4],\r
1862                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1863             }else if(IS_SUB_4X8(sub_mb_type)){\r
1864                 mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,\r
1865                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\r
1866                     &weight_op[5], &weight_avg[5],\r
1867                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1868                 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,\r
1869                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\r
1870                     &weight_op[5], &weight_avg[5],\r
1871                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1872             }else{\r
1873                 int j;\r
1874                 assert(IS_SUB_4X4(sub_mb_type));\r
1875                 for(j=0; j<4; j++){\r
1876                     int sub_x_offset= x_offset + 2*(j&1);\r
1877                     int sub_y_offset= y_offset +   (j&2);\r
1878                     mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,\r
1879                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\r
1880                         &weight_op[6], &weight_avg[6],\r
1881                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\r
1882                 }\r
1883             }\r
1884         }\r
1885     }\r
1886 \r
1887     prefetch_motion(h, 1);\r
1888 }\r
1889 \r
1890 static av_cold void init_cavlc_level_tab(void){\r
1891     int suffix_length, mask;\r
1892     unsigned int i;\r
1893 \r
1894     for(suffix_length=0; suffix_length<7; suffix_length++){\r
1895         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){\r
1896             int prefix= LEVEL_TAB_BITS - av_log2(2*i);\r
1897             int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);\r
1898 \r
1899             mask= -(level_code&1);\r
1900             level_code= (((2+level_code)>>1) ^ mask) - mask;\r
1901             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){\r
1902                 cavlc_level_tab[suffix_length][i][0]= level_code;\r
1903                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;\r
1904             }else if(prefix + 1 <= LEVEL_TAB_BITS){\r
1905                 cavlc_level_tab[suffix_length][i][0]= prefix+100;\r
1906                 cavlc_level_tab[suffix_length][i][1]= prefix + 1;\r
1907             }else{\r
1908                 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;\r
1909                 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;\r
1910             }\r
1911         }\r
1912     }\r
1913 }\r
1914 \r
1915 static av_cold void decode_init_vlc(void){\r
1916     static int done = 0;\r
1917 \r
1918     if (!done) {\r
1919         int i;\r
1920         int offset;\r
1921         done = 1;\r
1922 \r
1923         chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;\r
1924         chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;\r
1925         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,\r
1926                  &chroma_dc_coeff_token_len [0], 1, 1,\r
1927                  &chroma_dc_coeff_token_bits[0], 1, 1,\r
1928                  INIT_VLC_USE_NEW_STATIC);\r
1929 \r
1930         offset = 0;\r
1931         for(i=0; i<4; i++){\r
1932             coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;\r
1933             coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];\r
1934             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,\r
1935                      &coeff_token_len [i][0], 1, 1,\r
1936                      &coeff_token_bits[i][0], 1, 1,\r
1937                      INIT_VLC_USE_NEW_STATIC);\r
1938             offset += coeff_token_vlc_tables_size[i];\r
1939         }\r
1940         /*\r
1941          * This is a one time safety check to make sure that\r
1942          * the packed static coeff_token_vlc table sizes\r
1943          * were initialized correctly.\r
1944          */\r
1945         assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));\r
1946 \r
1947         for(i=0; i<3; i++){\r
1948             chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];\r
1949             chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;\r
1950             init_vlc(&chroma_dc_total_zeros_vlc[i],\r
1951                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,\r
1952                      &chroma_dc_total_zeros_len [i][0], 1, 1,\r
1953                      &chroma_dc_total_zeros_bits[i][0], 1, 1,\r
1954                      INIT_VLC_USE_NEW_STATIC);\r
1955         }\r
1956         for(i=0; i<15; i++){\r
1957             total_zeros_vlc[i].table = total_zeros_vlc_tables[i];\r
1958             total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;\r
1959             init_vlc(&total_zeros_vlc[i],\r
1960                      TOTAL_ZEROS_VLC_BITS, 16,\r
1961                      &total_zeros_len [i][0], 1, 1,\r
1962                      &total_zeros_bits[i][0], 1, 1,\r
1963                      INIT_VLC_USE_NEW_STATIC);\r
1964         }\r
1965 \r
1966         for(i=0; i<6; i++){\r
1967             run_vlc[i].table = run_vlc_tables[i];\r
1968             run_vlc[i].table_allocated = run_vlc_tables_size;\r
1969             init_vlc(&run_vlc[i],\r
1970                      RUN_VLC_BITS, 7,\r
1971                      &run_len [i][0], 1, 1,\r
1972                      &run_bits[i][0], 1, 1,\r
1973                      INIT_VLC_USE_NEW_STATIC);\r
1974         }\r
1975         run7_vlc.table = run7_vlc_table,\r
1976         run7_vlc.table_allocated = run7_vlc_table_size;\r
1977         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,\r
1978                  &run_len [6][0], 1, 1,\r
1979                  &run_bits[6][0], 1, 1,\r
1980                  INIT_VLC_USE_NEW_STATIC);\r
1981 \r
1982         init_cavlc_level_tab();\r
1983     }\r
1984 }\r
1985 \r
1986 static void free_tables(H264Context *h){\r
1987     int i;\r
1988     H264Context *hx;\r
1989     av_freep(&h->intra4x4_pred_mode);\r
1990     av_freep(&h->chroma_pred_mode_table);\r
1991     av_freep(&h->cbp_table);\r
1992     av_freep(&h->mvd_table[0]);\r
1993     av_freep(&h->mvd_table[1]);\r
1994     av_freep(&h->direct_table);\r
1995     av_freep(&h->non_zero_count);\r
1996     av_freep(&h->slice_table_base);\r
1997     h->slice_table= NULL;\r
1998 \r
1999     av_freep(&h->mb2b_xy);\r
2000     av_freep(&h->mb2b8_xy);\r
2001 \r
2002     for(i = 0; i < h->s.avctx->thread_count; i++) {\r
2003         hx = h->thread_context[i];\r
2004         if(!hx) continue;\r
2005         av_freep(&hx->top_borders[1]);\r
2006         av_freep(&hx->top_borders[0]);\r
2007         av_freep(&hx->s.obmc_scratchpad);\r
2008     }\r
2009 }\r
2010 \r
2011 static void init_dequant8_coeff_table(H264Context *h){\r
2012     int i,q,x;\r
2013     const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly\r
2014     h->dequant8_coeff[0] = h->dequant8_buffer[0];\r
2015     h->dequant8_coeff[1] = h->dequant8_buffer[1];\r
2016 \r
2017     for(i=0; i<2; i++ ){\r
2018         if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){\r
2019             h->dequant8_coeff[1] = h->dequant8_buffer[0];\r
2020             break;\r
2021         }\r
2022 \r
2023         for(q=0; q<52; q++){\r
2024             int shift = div6[q];\r
2025             int idx = rem6[q];\r
2026             for(x=0; x<64; x++)\r
2027                 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =\r
2028                     ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *\r
2029                     h->pps.scaling_matrix8[i][x]) << shift;\r
2030         }\r
2031     }\r
2032 }\r
2033 \r
2034 static void init_dequant4_coeff_table(H264Context *h){\r
2035     int i,j,q,x;\r
2036     const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly\r
2037     for(i=0; i<6; i++ ){\r
2038         h->dequant4_coeff[i] = h->dequant4_buffer[i];\r
2039         for(j=0; j<i; j++){\r
2040             if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){\r
2041                 h->dequant4_coeff[i] = h->dequant4_buffer[j];\r
2042                 break;\r
2043             }\r
2044         }\r
2045         if(j<i)\r
2046             continue;\r
2047 \r
2048         for(q=0; q<52; q++){\r
2049             int shift = div6[q] + 2;\r
2050             int idx = rem6[q];\r
2051             for(x=0; x<16; x++)\r
2052                 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =\r
2053                     ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *\r
2054                     h->pps.scaling_matrix4[i][x]) << shift;\r
2055         }\r
2056     }\r
2057 }\r
2058 \r
2059 static void init_dequant_tables(H264Context *h){\r
2060     int i,x;\r
2061     init_dequant4_coeff_table(h);\r
2062     if(h->pps.transform_8x8_mode)\r
2063         init_dequant8_coeff_table(h);\r
2064     if(h->sps.transform_bypass){\r
2065         for(i=0; i<6; i++)\r
2066             for(x=0; x<16; x++)\r
2067                 h->dequant4_coeff[i][0][x] = 1<<6;\r
2068         if(h->pps.transform_8x8_mode)\r
2069             for(i=0; i<2; i++)\r
2070                 for(x=0; x<64; x++)\r
2071                     h->dequant8_coeff[i][0][x] = 1<<6;\r
2072     }\r
2073 }\r
2074 \r
2075 \r
2076 /**\r
2077  * allocates tables.\r
2078  * needs width/height\r
2079  */\r
2080 static int alloc_tables(H264Context *h){\r
2081     MpegEncContext * const s = &h->s;\r
2082     const int big_mb_num= s->mb_stride * (s->mb_height+1);\r
2083     int x,y;\r
2084 \r
2085     CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8  * sizeof(uint8_t))\r
2086 \r
2087     CHECKED_ALLOCZ(h->non_zero_count    , big_mb_num * 16 * sizeof(uint8_t))\r
2088     CHECKED_ALLOCZ(h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base))\r
2089     CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))\r
2090 \r
2091     CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))\r
2092     CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));\r
2093     CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));\r
2094     CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));\r
2095 \r
2096     memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));\r
2097     h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;\r
2098 \r
2099     CHECKED_ALLOCZ(h->mb2b_xy  , big_mb_num * sizeof(uint32_t));\r
2100     CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));\r
2101     for(y=0; y<s->mb_height; y++){\r
2102         for(x=0; x<s->mb_width; x++){\r
2103             const int mb_xy= x + y*s->mb_stride;\r
2104             const int b_xy = 4*x + 4*y*h->b_stride;\r
2105             const int b8_xy= 2*x + 2*y*h->b8_stride;\r
2106 \r
2107             h->mb2b_xy [mb_xy]= b_xy;\r
2108             h->mb2b8_xy[mb_xy]= b8_xy;\r
2109         }\r
2110     }\r
2111 \r
2112     s->obmc_scratchpad = NULL;\r
2113 \r
2114     if(!h->dequant4_coeff[0])\r
2115         init_dequant_tables(h);\r
2116 \r
2117     return 0;\r
2118 fail:\r
2119     free_tables(h);\r
2120     return -1;\r
2121 }\r
2122 \r
2123 /**\r
2124  * Mimic alloc_tables(), but for every context thread.\r
2125  */\r
2126 static void clone_tables(H264Context *dst, H264Context *src){\r
2127     dst->intra4x4_pred_mode       = src->intra4x4_pred_mode;\r
2128     dst->non_zero_count           = src->non_zero_count;\r
2129     dst->slice_table              = src->slice_table;\r
2130     dst->cbp_table                = src->cbp_table;\r
2131     dst->mb2b_xy                  = src->mb2b_xy;\r
2132     dst->mb2b8_xy                 = src->mb2b8_xy;\r
2133     dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;\r
2134     dst->mvd_table[0]             = src->mvd_table[0];\r
2135     dst->mvd_table[1]             = src->mvd_table[1];\r
2136     dst->direct_table             = src->direct_table;\r
2137 \r
2138     dst->s.obmc_scratchpad = NULL;\r
2139     ff_h264_pred_init(&dst->hpc, src->s.codec_id);\r
2140 }\r
2141 \r
2142 /**\r
2143  * Init context\r
2144  * Allocate buffers which are not shared amongst multiple threads.\r
2145  */\r
2146 static int context_init(H264Context *h){\r
2147     CHECKED_ALLOCZ(h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t))\r
2148     CHECKED_ALLOCZ(h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t))\r
2149 \r
2150     return 0;\r
2151 fail:\r
2152     return -1; // free_tables will clean up for us\r
2153 }\r
2154 \r
2155 static av_cold void common_init(H264Context *h){\r
2156     MpegEncContext * const s = &h->s;\r
2157 \r
2158     s->width = s->avctx->width;\r
2159     s->height = s->avctx->height;\r
2160     s->codec_id= s->avctx->codec->id;\r
2161 \r
2162     ff_h264_pred_init(&h->hpc, s->codec_id);\r
2163 \r
2164     h->dequant_coeff_pps= -1;\r
2165     s->unrestricted_mv=1;\r
2166     s->decode=1; //FIXME\r
2167 \r
2168     dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early\r
2169 \r
2170     memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));\r
2171     memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));\r
2172 }\r
2173 \r
2174 static av_cold int decode_init(AVCodecContext *avctx){\r
2175     H264Context *h= avctx->priv_data;\r
2176     MpegEncContext * const s = &h->s;\r
2177 \r
2178     MPV_decode_defaults(s);\r
2179 \r
2180     s->avctx = avctx;\r
2181     common_init(h);\r
2182 \r
2183     s->out_format = FMT_H264;\r
2184     s->workaround_bugs= avctx->workaround_bugs;\r
2185 \r
2186     // set defaults\r
2187 //    s->decode_mb= ff_h263_decode_mb;\r
2188     s->quarter_sample = 1;\r
2189     s->low_delay= 1;\r
2190 \r
2191     if(avctx->codec_id == CODEC_ID_SVQ3)\r
2192         avctx->pix_fmt= PIX_FMT_YUVJ420P;\r
2193     else if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)\r
2194         avctx->pix_fmt= PIX_FMT_VDPAU_H264;\r
2195     else\r
2196         avctx->pix_fmt= PIX_FMT_YUV420P;\r
2197 \r
2198     decode_init_vlc();\r
2199 \r
2200     if(avctx->extradata_size > 0 && avctx->extradata &&\r
2201        *(char *)avctx->extradata == 1){\r
2202         h->is_avc = 1;\r
2203         h->got_avcC = 0;\r
2204     } else {\r
2205         h->is_avc = 0;\r
2206     }\r
2207 \r
2208     h->thread_context[0] = h;\r
2209     h->outputed_poc = INT_MIN;\r
2210     h->prev_poc_msb= 1<<16;\r
2211     h->sei_recovery_frame_cnt = -1;\r
2212     return 0;\r
2213 }\r
2214 \r
2215 static int frame_start(H264Context *h){\r
2216     MpegEncContext * const s = &h->s;\r
2217     int i;\r
2218 \r
2219     if(MPV_frame_start(s, s->avctx) < 0)\r
2220         return -1;\r
2221     ff_er_frame_start(s);\r
2222     /*\r
2223      * MPV_frame_start uses pict_type to derive key_frame.\r
2224      * This is incorrect for H.264; IDR markings must be used.\r
2225      * Zero here; IDR markings per slice in frame or fields are ORed in later.\r
2226      * See decode_nal_units().\r
2227      */\r
2228     s->current_picture_ptr->key_frame= 0;\r
2229 \r
2230     assert(s->linesize && s->uvlinesize);\r
2231 \r
2232     for(i=0; i<16; i++){\r
2233         h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);\r
2234         h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);\r
2235     }\r
2236     for(i=0; i<4; i++){\r
2237         h->block_offset[16+i]=\r
2238         h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);\r
2239         h->block_offset[24+16+i]=\r
2240         h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);\r
2241     }\r
2242 \r
2243     /* can't be in alloc_tables because linesize isn't known there.\r
2244      * FIXME: redo bipred weight to not require extra buffer? */\r
2245     for(i = 0; i < s->avctx->thread_count; i++)\r
2246         if(!h->thread_context[i]->s.obmc_scratchpad)\r
2247             h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);\r
2248 \r
2249     /* some macroblocks will be accessed before they're available */\r
2250     if(FRAME_MBAFF || s->avctx->thread_count > 1)\r
2251         memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));\r
2252 \r
2253 //    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;\r
2254 \r
2255     // We mark the current picture as non-reference after allocating it, so\r
2256     // that if we break out due to an error it can be released automatically\r
2257     // in the next MPV_frame_start().\r
2258     // SVQ3 as well as most other codecs have only last/next/current and thus\r
2259     // get released even with set reference, besides SVQ3 and others do not\r
2260     // mark frames as reference later "naturally".\r
2261     if(s->codec_id != CODEC_ID_SVQ3)\r
2262         s->current_picture_ptr->reference= 0;\r
2263 \r
2264     s->current_picture_ptr->field_poc[0]=\r
2265     s->current_picture_ptr->field_poc[1]= INT_MAX;\r
2266     assert(s->current_picture_ptr->long_ref==0);\r
2267 \r
2268     return 0;\r
2269 }\r
2270 \r
2271 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){\r
2272     MpegEncContext * const s = &h->s;\r
2273     int i;\r
2274     int step    = 1;\r
2275     int offset  = 1;\r
2276     int uvoffset= 1;\r
2277     int top_idx = 1;\r
2278     int skiplast= 0;\r
2279 \r
2280     src_y  -=   linesize;\r
2281     src_cb -= uvlinesize;\r
2282     src_cr -= uvlinesize;\r
2283 \r
2284     if(!simple && FRAME_MBAFF){\r
2285         if(s->mb_y&1){\r
2286             offset  = MB_MBAFF ? 1 : 17;\r
2287             uvoffset= MB_MBAFF ? 1 : 9;\r
2288             if(!MB_MBAFF){\r
2289                 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y +  15*linesize);\r
2290                 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);\r
2291                 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){\r
2292                     *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);\r
2293                     *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);\r
2294                 }\r
2295             }\r
2296         }else{\r
2297             if(!MB_MBAFF){\r
2298                 h->left_border[0]= h->top_borders[0][s->mb_x][15];\r
2299                 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){\r
2300                     h->left_border[34   ]= h->top_borders[0][s->mb_x][16+7  ];\r
2301                     h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];\r
2302                 }\r
2303                 skiplast= 1;\r
2304             }\r
2305             offset  =\r
2306             uvoffset=\r
2307             top_idx = MB_MBAFF ? 0 : 1;\r
2308         }\r
2309         step= MB_MBAFF ? 2 : 1;\r
2310     }\r
2311 \r
2312     // There are two lines saved, the line above the the top macroblock of a pair,\r
2313     // and the line above the bottom macroblock\r
2314     h->left_border[offset]= h->top_borders[top_idx][s->mb_x][15];\r
2315     for(i=1; i<17 - skiplast; i++){\r
2316         h->left_border[offset+i*step]= src_y[15+i*  linesize];\r
2317     }\r
2318 \r
2319     *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);\r
2320     *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);\r
2321 \r
2322     if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){\r
2323         h->left_border[uvoffset+34   ]= h->top_borders[top_idx][s->mb_x][16+7];\r