h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot...
[ffmpeg.git] / libavcodec / h264.c
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  */
20  
21 /**
22  * @file h264.c
23  * H.264 / AVC / MPEG4 part10 codec.
24  * @author Michael Niedermayer <michaelni@gmx.at>
25  */
26
27 #include "common.h"
28 #include "dsputil.h"
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "h264data.h"
32 #include "golomb.h"
33
34 #include "cabac.h"
35
36 #undef NDEBUG
37 #include <assert.h>
38
39 #define interlaced_dct interlaced_dct_is_a_bad_name
40 #define mb_intra mb_intra_isnt_initalized_see_mb_type
41
42 #define LUMA_DC_BLOCK_INDEX   25
43 #define CHROMA_DC_BLOCK_INDEX 26
44
45 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
46 #define COEFF_TOKEN_VLC_BITS           8
47 #define TOTAL_ZEROS_VLC_BITS           9
48 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
49 #define RUN_VLC_BITS                   3
50 #define RUN7_VLC_BITS                  6
51
52 #define MAX_SPS_COUNT 32
53 #define MAX_PPS_COUNT 256
54
55 #define MAX_MMCO_COUNT 66
56
57 /**
58  * Sequence parameter set
59  */
60 typedef struct SPS{
61     
62     int profile_idc;
63     int level_idc;
64     int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
65     int poc_type;                      ///< pic_order_cnt_type
66     int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
67     int delta_pic_order_always_zero_flag;
68     int offset_for_non_ref_pic;
69     int offset_for_top_to_bottom_field;
70     int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
71     int ref_frame_count;               ///< num_ref_frames
72     int gaps_in_frame_num_allowed_flag;
73     int mb_width;                      ///< frame_width_in_mbs_minus1 + 1
74     int mb_height;                     ///< frame_height_in_mbs_minus1 + 1
75     int frame_mbs_only_flag;
76     int mb_aff;                        ///<mb_adaptive_frame_field_flag
77     int direct_8x8_inference_flag;
78     int crop;                   ///< frame_cropping_flag
79     int crop_left;              ///< frame_cropping_rect_left_offset
80     int crop_right;             ///< frame_cropping_rect_right_offset
81     int crop_top;               ///< frame_cropping_rect_top_offset
82     int crop_bottom;            ///< frame_cropping_rect_bottom_offset
83     int vui_parameters_present_flag;
84     AVRational sar;
85     short offset_for_ref_frame[256]; //FIXME dyn aloc?
86 }SPS;
87
88 /**
89  * Picture parameter set
90  */
91 typedef struct PPS{
92     int sps_id;
93     int cabac;                  ///< entropy_coding_mode_flag
94     int pic_order_present;      ///< pic_order_present_flag
95     int slice_group_count;      ///< num_slice_groups_minus1 + 1
96     int mb_slice_group_map_type;
97     int ref_count[2];           ///< num_ref_idx_l0/1_active_minus1 + 1
98     int weighted_pred;          ///< weighted_pred_flag
99     int weighted_bipred_idc;
100     int init_qp;                ///< pic_init_qp_minus26 + 26
101     int init_qs;                ///< pic_init_qs_minus26 + 26
102     int chroma_qp_index_offset;
103     int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
104     int constrained_intra_pred; ///< constrained_intra_pred_flag
105     int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
106 }PPS;
107
108 /**
109  * Memory management control operation opcode.
110  */
111 typedef enum MMCOOpcode{
112     MMCO_END=0,
113     MMCO_SHORT2UNUSED,
114     MMCO_LONG2UNUSED,
115     MMCO_SHORT2LONG,
116     MMCO_SET_MAX_LONG,
117     MMCO_RESET, 
118     MMCO_LONG,
119 } MMCOOpcode;
120
121 /**
122  * Memory management control operation.
123  */
124 typedef struct MMCO{
125     MMCOOpcode opcode;
126     int short_frame_num;
127     int long_index;
128 } MMCO;
129
130 /**
131  * H264Context
132  */
133 typedef struct H264Context{
134     MpegEncContext s;
135     int nal_ref_idc;    
136     int nal_unit_type;
137 #define NAL_SLICE               1
138 #define NAL_DPA                 2
139 #define NAL_DPB                 3
140 #define NAL_DPC                 4
141 #define NAL_IDR_SLICE           5
142 #define NAL_SEI                 6
143 #define NAL_SPS                 7
144 #define NAL_PPS                 8
145 #define NAL_PICTURE_DELIMITER   9
146 #define NAL_FILTER_DATA         10
147     uint8_t *rbsp_buffer;
148     int rbsp_buffer_size;
149
150     int chroma_qp; //QPc
151
152     int prev_mb_skiped; //FIXME remove (IMHO not used)
153
154     //prediction stuff
155     int chroma_pred_mode;
156     int intra16x16_pred_mode;
157     
158     int8_t intra4x4_pred_mode_cache[5*8];
159     int8_t (*intra4x4_pred_mode)[8];
160     void (*pred4x4  [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?
161     void (*pred8x8  [4+3])(uint8_t *src, int stride);
162     void (*pred16x16[4+3])(uint8_t *src, int stride);
163     unsigned int topleft_samples_available;
164     unsigned int top_samples_available;
165     unsigned int topright_samples_available;
166     unsigned int left_samples_available;
167     uint8_t (*top_border)[16+2*8];
168     uint8_t left_border[17+2*9];
169
170     /**
171      * non zero coeff count cache.
172      * is 64 if not available.
173      */
174     uint8_t non_zero_count_cache[6*8];
175     uint8_t (*non_zero_count)[16];
176
177     /**
178      * Motion vector cache.
179      */
180     int16_t mv_cache[2][5*8][2];
181     int8_t ref_cache[2][5*8];
182 #define LIST_NOT_USED -1 //FIXME rename?
183 #define PART_NOT_AVAILABLE -2
184     
185     /**
186      * is 1 if the specific list MV&references are set to 0,0,-2.
187      */
188     int mv_cache_clean[2];
189
190     int block_offset[16+8];
191     int chroma_subblock_offset[16]; //FIXME remove
192     
193     uint16_t *mb2b_xy; //FIXME are these 4 a good idea?
194     uint16_t *mb2b8_xy;
195     int b_stride;
196     int b8_stride;
197
198     int halfpel_flag;
199     int thirdpel_flag;
200
201     int unknown_svq3_flag;
202     int next_slice_index;
203
204     SPS sps_buffer[MAX_SPS_COUNT];
205     SPS sps; ///< current sps
206     
207     PPS pps_buffer[MAX_PPS_COUNT];
208     /**
209      * current pps
210      */
211     PPS pps; //FIXME move tp Picture perhaps? (->no) do we need that?
212
213     int slice_num;
214     uint8_t *slice_table_base;
215     uint8_t *slice_table;      ///< slice_table_base + mb_stride + 1
216     int slice_type;
217     int slice_type_fixed;
218     
219     //interlacing specific flags
220     int mb_field_decoding_flag;
221     
222     int sub_mb_type[4];
223     
224     //POC stuff
225     int poc_lsb;
226     int poc_msb;
227     int delta_poc_bottom;
228     int delta_poc[2];
229     int frame_num;
230     int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
231     int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
232     int frame_num_offset;         ///< for POC type 2
233     int prev_frame_num_offset;    ///< for POC type 2
234     int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2
235
236     /**
237      * frame_num for frames or 2*frame_num for field pics.
238      */
239     int curr_pic_num;
240     
241     /**
242      * max_frame_num or 2*max_frame_num for field pics.
243      */
244     int max_pic_num;
245
246     //Weighted pred stuff
247     int luma_log2_weight_denom;
248     int chroma_log2_weight_denom;
249     int luma_weight[2][16];
250     int luma_offset[2][16];
251     int chroma_weight[2][16][2];
252     int chroma_offset[2][16][2];
253    
254     //deblock
255     int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0 
256     int slice_alpha_c0_offset;
257     int slice_beta_offset;
258      
259     int redundant_pic_count;
260     
261     int direct_spatial_mv_pred;
262
263     /**
264      * num_ref_idx_l0/1_active_minus1 + 1
265      */
266     int ref_count[2];// FIXME split for AFF
267     Picture *short_ref[16];
268     Picture *long_ref[16];
269     Picture default_ref_list[2][32];
270     Picture ref_list[2][32]; //FIXME size?
271     Picture field_ref_list[2][32]; //FIXME size?
272     
273     /**
274      * memory management control operations buffer.
275      */
276     MMCO mmco[MAX_MMCO_COUNT];
277     int mmco_index;
278     
279     int long_ref_count;  ///< number of actual long term references
280     int short_ref_count; ///< number of actual short term references
281     
282     //data partitioning
283     GetBitContext intra_gb;
284     GetBitContext inter_gb;
285     GetBitContext *intra_gb_ptr;
286     GetBitContext *inter_gb_ptr;
287     
288     DCTELEM mb[16*24] __align8;
289
290     /**
291      * Cabac
292      */
293     CABACContext cabac;
294     uint8_t      cabac_state[399];
295     int          cabac_init_idc;
296
297     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
298     uint16_t     *cbp_table;
299     uint8_t     *chroma_pred_mode_table;
300     int         last_qscale_diff;
301
302 }H264Context;
303
304 static VLC coeff_token_vlc[4];
305 static VLC chroma_dc_coeff_token_vlc;
306
307 static VLC total_zeros_vlc[15];
308 static VLC chroma_dc_total_zeros_vlc[3];
309
310 static VLC run_vlc[6];
311 static VLC run7_vlc;
312
313 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
314 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
315 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr);
316
317 static inline uint32_t pack16to32(int a, int b){
318 #ifdef WORDS_BIGENDIAN
319    return (b&0xFFFF) + (a<<16);
320 #else
321    return (a&0xFFFF) + (b<<16);
322 #endif
323 }
324
325 /**
326  * fill a rectangle.
327  * @param h height of the recatangle, should be a constant
328  * @param w width of the recatangle, should be a constant
329  * @param size the size of val (1 or 4), should be a constant
330  */
331 static inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ //FIXME ensure this IS inlined
332     uint8_t *p= (uint8_t*)vp;
333     assert(size==1 || size==4);
334     
335     w      *= size;
336     stride *= size;
337     
338 //FIXME check what gcc generates for 64 bit on x86 and possible write a 32 bit ver of it
339     if(w==2 && h==2){
340         *(uint16_t*)(p + 0)=
341         *(uint16_t*)(p + stride)= size==4 ? val : val*0x0101;
342     }else if(w==2 && h==4){
343         *(uint16_t*)(p + 0*stride)=
344         *(uint16_t*)(p + 1*stride)=
345         *(uint16_t*)(p + 2*stride)=
346         *(uint16_t*)(p + 3*stride)= size==4 ? val : val*0x0101;
347     }else if(w==4 && h==1){
348         *(uint32_t*)(p + 0*stride)= size==4 ? val : val*0x01010101;
349     }else if(w==4 && h==2){
350         *(uint32_t*)(p + 0*stride)=
351         *(uint32_t*)(p + 1*stride)= size==4 ? val : val*0x01010101;
352     }else if(w==4 && h==4){
353         *(uint32_t*)(p + 0*stride)=
354         *(uint32_t*)(p + 1*stride)=
355         *(uint32_t*)(p + 2*stride)=
356         *(uint32_t*)(p + 3*stride)= size==4 ? val : val*0x01010101;
357     }else if(w==8 && h==1){
358         *(uint32_t*)(p + 0)=
359         *(uint32_t*)(p + 4)= size==4 ? val : val*0x01010101;
360     }else if(w==8 && h==2){
361         *(uint32_t*)(p + 0 + 0*stride)=
362         *(uint32_t*)(p + 4 + 0*stride)=
363         *(uint32_t*)(p + 0 + 1*stride)=
364         *(uint32_t*)(p + 4 + 1*stride)=  size==4 ? val : val*0x01010101;
365     }else if(w==8 && h==4){
366         *(uint64_t*)(p + 0*stride)=
367         *(uint64_t*)(p + 1*stride)=
368         *(uint64_t*)(p + 2*stride)=
369         *(uint64_t*)(p + 3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
370     }else if(w==16 && h==2){
371         *(uint64_t*)(p + 0+0*stride)=
372         *(uint64_t*)(p + 8+0*stride)=
373         *(uint64_t*)(p + 0+1*stride)=
374         *(uint64_t*)(p + 8+1*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
375     }else if(w==16 && h==4){
376         *(uint64_t*)(p + 0+0*stride)=
377         *(uint64_t*)(p + 8+0*stride)=
378         *(uint64_t*)(p + 0+1*stride)=
379         *(uint64_t*)(p + 8+1*stride)=
380         *(uint64_t*)(p + 0+2*stride)=
381         *(uint64_t*)(p + 8+2*stride)=
382         *(uint64_t*)(p + 0+3*stride)=
383         *(uint64_t*)(p + 8+3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
384     }else
385         assert(0);
386 }
387
388 static inline void fill_caches(H264Context *h, int mb_type){
389     MpegEncContext * const s = &h->s;
390     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
391     int topleft_xy, top_xy, topright_xy, left_xy[2];
392     int topleft_type, top_type, topright_type, left_type[2];
393     int left_block[4];
394     int i;
395
396     //wow what a mess, why didnt they simplify the interlacing&intra stuff, i cant imagine that these complex rules are worth it 
397     
398     if(h->sps.mb_aff){
399     //FIXME
400         topleft_xy = 0; /* avoid warning */
401         top_xy = 0; /* avoid warning */
402         topright_xy = 0; /* avoid warning */
403     }else{
404         topleft_xy = mb_xy-1 - s->mb_stride;
405         top_xy     = mb_xy   - s->mb_stride;
406         topright_xy= mb_xy+1 - s->mb_stride;
407         left_xy[0]   = mb_xy-1;
408         left_xy[1]   = mb_xy-1;
409         left_block[0]= 0;
410         left_block[1]= 1;
411         left_block[2]= 2;
412         left_block[3]= 3;
413     }
414
415     topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
416     top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;
417     topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
418     left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
419     left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
420
421     if(IS_INTRA(mb_type)){
422         h->topleft_samples_available= 
423         h->top_samples_available= 
424         h->left_samples_available= 0xFFFF;
425         h->topright_samples_available= 0xEEEA;
426
427         if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){
428             h->topleft_samples_available= 0xB3FF;
429             h->top_samples_available= 0x33FF;
430             h->topright_samples_available= 0x26EA;
431         }
432         for(i=0; i<2; i++){
433             if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){
434                 h->topleft_samples_available&= 0xDF5F;
435                 h->left_samples_available&= 0x5F5F;
436             }
437         }
438         
439         if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))
440             h->topleft_samples_available&= 0x7FFF;
441         
442         if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))
443             h->topright_samples_available&= 0xFBFF;
444     
445         if(IS_INTRA4x4(mb_type)){
446             if(IS_INTRA4x4(top_type)){
447                 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
448                 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
449                 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
450                 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
451             }else{
452                 int pred;
453                 if(IS_INTRA16x16(top_type) || (IS_INTER(top_type) && !h->pps.constrained_intra_pred))
454                     pred= 2;
455                 else{
456                     pred= -1;
457                 }
458                 h->intra4x4_pred_mode_cache[4+8*0]=
459                 h->intra4x4_pred_mode_cache[5+8*0]=
460                 h->intra4x4_pred_mode_cache[6+8*0]=
461                 h->intra4x4_pred_mode_cache[7+8*0]= pred;
462             }
463             for(i=0; i<2; i++){
464                 if(IS_INTRA4x4(left_type[i])){
465                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
466                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
467                 }else{
468                     int pred;
469                     if(IS_INTRA16x16(left_type[i]) || (IS_INTER(left_type[i]) && !h->pps.constrained_intra_pred))
470                         pred= 2;
471                     else{
472                         pred= -1;
473                     }
474                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
475                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
476                 }
477             }
478         }
479     }
480     
481     
482 /*
483 0 . T T. T T T T 
484 1 L . .L . . . . 
485 2 L . .L . . . . 
486 3 . T TL . . . . 
487 4 L . .L . . . . 
488 5 L . .. . . . . 
489 */
490 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)
491     if(top_type){
492         h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][0];
493         h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][1];
494         h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][2];
495         h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
496     
497         h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][7];
498         h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
499     
500         h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][10];
501         h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
502     }else{
503         h->non_zero_count_cache[4+8*0]=      
504         h->non_zero_count_cache[5+8*0]=
505         h->non_zero_count_cache[6+8*0]=
506         h->non_zero_count_cache[7+8*0]=
507     
508         h->non_zero_count_cache[1+8*0]=
509         h->non_zero_count_cache[2+8*0]=
510     
511         h->non_zero_count_cache[1+8*3]=
512         h->non_zero_count_cache[2+8*3]= 64;
513     }
514     
515     if(left_type[0]){
516         h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][6];
517         h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][5];
518         h->non_zero_count_cache[0+8*1]= h->non_zero_count[left_xy[0]][9]; //FIXME left_block
519         h->non_zero_count_cache[0+8*4]= h->non_zero_count[left_xy[0]][12];
520     }else{
521         h->non_zero_count_cache[3+8*1]= 
522         h->non_zero_count_cache[3+8*2]= 
523         h->non_zero_count_cache[0+8*1]= 
524         h->non_zero_count_cache[0+8*4]= 64;
525     }
526     
527     if(left_type[1]){
528         h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[1]][4];
529         h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[1]][3];
530         h->non_zero_count_cache[0+8*2]= h->non_zero_count[left_xy[1]][8];
531         h->non_zero_count_cache[0+8*5]= h->non_zero_count[left_xy[1]][11];
532     }else{
533         h->non_zero_count_cache[3+8*3]= 
534         h->non_zero_count_cache[3+8*4]= 
535         h->non_zero_count_cache[0+8*2]= 
536         h->non_zero_count_cache[0+8*5]= 64;
537     }
538     
539 #if 1
540     if(IS_INTER(mb_type)){
541         int list;
542         for(list=0; list<2; list++){
543             if((!IS_8X8(mb_type)) && !USES_LIST(mb_type, list)){
544                 /*if(!h->mv_cache_clean[list]){
545                     memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
546                     memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
547                     h->mv_cache_clean[list]= 1;
548                 }*/
549                 continue; //FIXME direct mode ...
550             }
551             h->mv_cache_clean[list]= 0;
552             
553             if(IS_INTER(topleft_type)){
554                 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
555                 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;
556                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
557                 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
558             }else{
559                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
560                 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
561             }
562             
563             if(IS_INTER(top_type)){
564                 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
565                 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
566                 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
567                 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
568                 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
569                 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
570                 h->ref_cache[list][scan8[0] + 0 - 1*8]=
571                 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
572                 h->ref_cache[list][scan8[0] + 2 - 1*8]=
573                 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
574             }else{
575                 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= 
576                 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= 
577                 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= 
578                 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
579                 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
580             }
581
582             if(IS_INTER(topright_type)){
583                 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
584                 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
585                 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
586                 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
587             }else{
588                 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
589                 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
590             }
591             
592             //FIXME unify cleanup or sth
593             if(IS_INTER(left_type[0])){
594                 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
595                 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
596                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]];
597                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]];
598                 h->ref_cache[list][scan8[0] - 1 + 0*8]= 
599                 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];
600             }else{
601                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=
602                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;
603                 h->ref_cache[list][scan8[0] - 1 + 0*8]=
604                 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
605             }
606             
607             if(IS_INTER(left_type[1])){
608                 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
609                 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;
610                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]];
611                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]];
612                 h->ref_cache[list][scan8[0] - 1 + 2*8]= 
613                 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];
614             }else{
615                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=
616                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;
617                 h->ref_cache[list][scan8[0] - 1 + 2*8]=
618                 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
619             }
620
621             h->ref_cache[list][scan8[5 ]+1] = 
622             h->ref_cache[list][scan8[7 ]+1] = 
623             h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewher else)
624             h->ref_cache[list][scan8[4 ]] = 
625             h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
626             *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
627             *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
628             *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewher else)
629             *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
630             *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
631         }
632 //FIXME
633
634     }
635 #endif
636 }
637
638 static inline void write_back_intra_pred_mode(H264Context *h){
639     MpegEncContext * const s = &h->s;
640     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
641
642     h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
643     h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
644     h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
645     h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
646     h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
647     h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
648     h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
649 }
650
651 /**
652  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
653  */
654 static inline int check_intra4x4_pred_mode(H264Context *h){
655     MpegEncContext * const s = &h->s;
656     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
657     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
658     int i;
659     
660     if(!(h->top_samples_available&0x8000)){
661         for(i=0; i<4; i++){
662             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
663             if(status<0){
664                 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);
665                 return -1;
666             } else if(status){
667                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
668             }
669         }
670     }
671     
672     if(!(h->left_samples_available&0x8000)){
673         for(i=0; i<4; i++){
674             int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
675             if(status<0){
676                 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);
677                 return -1;
678             } else if(status){
679                 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
680             }
681         }
682     }
683
684     return 0;
685 } //FIXME cleanup like next
686
687 /**
688  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
689  */
690 static inline int check_intra_pred_mode(H264Context *h, int mode){
691     MpegEncContext * const s = &h->s;
692     static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
693     static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
694     
695     if(!(h->top_samples_available&0x8000)){
696         mode= top[ mode ];
697         if(mode<0){
698             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);
699             return -1;
700         }
701     }
702     
703     if(!(h->left_samples_available&0x8000)){
704         mode= left[ mode ];
705         if(mode<0){
706             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);
707             return -1;
708         } 
709     }
710
711     return mode;
712 }
713
714 /**
715  * gets the predicted intra4x4 prediction mode.
716  */
717 static inline int pred_intra_mode(H264Context *h, int n){
718     const int index8= scan8[n];
719     const int left= h->intra4x4_pred_mode_cache[index8 - 1];
720     const int top = h->intra4x4_pred_mode_cache[index8 - 8];
721     const int min= FFMIN(left, top);
722
723     tprintf("mode:%d %d min:%d\n", left ,top, min);
724
725     if(min<0) return DC_PRED;
726     else      return min;
727 }
728
729 static inline void write_back_non_zero_count(H264Context *h){
730     MpegEncContext * const s = &h->s;
731     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
732
733     h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[4+8*4];
734     h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[5+8*4];
735     h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[6+8*4];
736     h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
737     h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[7+8*3];
738     h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[7+8*2];
739     h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[7+8*1];
740     
741     h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[1+8*2];
742     h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
743     h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[2+8*1];
744
745     h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[1+8*5];
746     h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
747     h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[2+8*4];
748 }
749
750 /**
751  * gets the predicted number of non zero coefficients.
752  * @param n block index
753  */
754 static inline int pred_non_zero_count(H264Context *h, int n){
755     const int index8= scan8[n];
756     const int left= h->non_zero_count_cache[index8 - 1];
757     const int top = h->non_zero_count_cache[index8 - 8];
758     int i= left + top;
759     
760     if(i<64) i= (i+1)>>1;
761
762     tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
763
764     return i&31;
765 }
766
767 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
768     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
769
770     if(topright_ref != PART_NOT_AVAILABLE){
771         *C= h->mv_cache[list][ i - 8 + part_width ];
772         return topright_ref;
773     }else{
774         tprintf("topright MV not available\n");
775
776         *C= h->mv_cache[list][ i - 8 - 1 ];
777         return h->ref_cache[list][ i - 8 - 1 ];
778     }
779 }
780
781 /**
782  * gets the predicted MV.
783  * @param n the block index
784  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
785  * @param mx the x component of the predicted motion vector
786  * @param my the y component of the predicted motion vector
787  */
788 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
789     const int index8= scan8[n];
790     const int top_ref=      h->ref_cache[list][ index8 - 8 ];
791     const int left_ref=     h->ref_cache[list][ index8 - 1 ];
792     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
793     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
794     const int16_t * C;
795     int diagonal_ref, match_count;
796
797     assert(part_width==1 || part_width==2 || part_width==4);
798
799 /* mv_cache
800   B . . A T T T T 
801   U . . L . . , .
802   U . . L . . . .
803   U . . L . . , .
804   . . . L . . . .
805 */
806
807     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
808     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
809     if(match_count > 1){ //most common
810         *mx= mid_pred(A[0], B[0], C[0]);
811         *my= mid_pred(A[1], B[1], C[1]);
812     }else if(match_count==1){
813         if(left_ref==ref){
814             *mx= A[0];
815             *my= A[1];        
816         }else if(top_ref==ref){
817             *mx= B[0];
818             *my= B[1];        
819         }else{
820             *mx= C[0];
821             *my= C[1];        
822         }
823     }else{
824         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
825             *mx= A[0];
826             *my= A[1];        
827         }else{
828             *mx= mid_pred(A[0], B[0], C[0]);
829             *my= mid_pred(A[1], B[1], C[1]);
830         }
831     }
832         
833     tprintf("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);
834 }
835
836 /**
837  * gets the directionally predicted 16x8 MV.
838  * @param n the block index
839  * @param mx the x component of the predicted motion vector
840  * @param my the y component of the predicted motion vector
841  */
842 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
843     if(n==0){
844         const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];
845         const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
846
847         tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list);
848         
849         if(top_ref == ref){
850             *mx= B[0];
851             *my= B[1];
852             return;
853         }
854     }else{
855         const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];
856         const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
857         
858         tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);
859
860         if(left_ref == ref){
861             *mx= A[0];
862             *my= A[1];
863             return;
864         }
865     }
866
867     //RARE
868     pred_motion(h, n, 4, list, ref, mx, my);
869 }
870
871 /**
872  * gets the directionally predicted 8x16 MV.
873  * @param n the block index
874  * @param mx the x component of the predicted motion vector
875  * @param my the y component of the predicted motion vector
876  */
877 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
878     if(n==0){
879         const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];
880         const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];
881         
882         tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);
883
884         if(left_ref == ref){
885             *mx= A[0];
886             *my= A[1];
887             return;
888         }
889     }else{
890         const int16_t * C;
891         int diagonal_ref;
892
893         diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
894         
895         tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list);
896
897         if(diagonal_ref == ref){ 
898             *mx= C[0];
899             *my= C[1];
900             return;
901         }
902     }
903
904     //RARE
905     pred_motion(h, n, 2, list, ref, mx, my);
906 }
907
908 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
909     const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
910     const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
911
912     tprintf("pred_pskip: (%d) (%d) at %2d %2d", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
913
914     if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
915        || (top_ref == 0  && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
916        || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
917        
918         *mx = *my = 0;
919         return;
920     }
921         
922     pred_motion(h, 0, 4, 0, 0, mx, my);
923
924     return;
925 }
926
927 static inline void write_back_motion(H264Context *h, int mb_type){
928     MpegEncContext * const s = &h->s;
929     const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
930     const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
931     int list;
932
933     for(list=0; list<2; list++){
934         int y;
935         if((!IS_8X8(mb_type)) && !USES_LIST(mb_type, list)){
936             if(1){ //FIXME skip or never read if mb_type doesnt use it
937                 for(y=0; y<4; y++){
938                     *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]=
939                     *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= 0;
940                 }
941                 for(y=0; y<2; y++){
942                     *(uint16_t*)s->current_picture.motion_val[list][b8_xy + y*h->b8_stride]= (LIST_NOT_USED&0xFF)*0x0101;
943                 }
944             }
945             continue; //FIXME direct mode ...
946         }
947         
948         for(y=0; y<4; y++){
949             *(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];
950             *(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];
951         }
952         for(y=0; y<2; y++){
953             s->current_picture.ref_index[list][b8_xy + 0 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+0 + 16*y];
954             s->current_picture.ref_index[list][b8_xy + 1 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+2 + 16*y];
955         }
956     }
957 }
958
959 /**
960  * Decodes a network abstraction layer unit.
961  * @param consumed is the number of bytes used as input
962  * @param length is the length of the array
963  * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp ttailing?
964  * @returns decoded bytes, might be src+1 if no escapes 
965  */
966 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){
967     int i, si, di;
968     uint8_t *dst;
969
970 //    src[0]&0x80;              //forbidden bit
971     h->nal_ref_idc= src[0]>>5;
972     h->nal_unit_type= src[0]&0x1F;
973
974     src++; length--;
975 #if 0    
976     for(i=0; i<length; i++)
977         printf("%2X ", src[i]);
978 #endif
979     for(i=0; i+1<length; i+=2){
980         if(src[i]) continue;
981         if(i>0 && src[i-1]==0) i--;
982         if(i+2<length && src[i+1]==0 && src[i+2]<=3){
983             if(src[i+2]!=3){
984                 /* startcode, so we must be past the end */
985                 length=i;
986             }
987             break;
988         }
989     }
990
991     if(i>=length-1){ //no escaped 0
992         *dst_length= length;
993         *consumed= length+1; //+1 for the header
994         return src; 
995     }
996
997     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);
998     dst= h->rbsp_buffer;
999
1000 //printf("deoding esc\n");
1001     si=di=0;
1002     while(si<length){ 
1003         //remove escapes (very rare 1:2^22)
1004         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1005             if(src[si+2]==3){ //escape
1006                 dst[di++]= 0;
1007                 dst[di++]= 0;
1008                 si+=3;
1009             }else //next start code
1010                 break;
1011         }
1012
1013         dst[di++]= src[si++];
1014     }
1015
1016     *dst_length= di;
1017     *consumed= si + 1;//+1 for the header
1018 //FIXME store exact number of bits in the getbitcontext (its needed for decoding)
1019     return dst;
1020 }
1021
1022 #if 0
1023 /**
1024  * @param src the data which should be escaped
1025  * @param dst the target buffer, dst+1 == src is allowed as a special case
1026  * @param length the length of the src data
1027  * @param dst_length the length of the dst array
1028  * @returns length of escaped data in bytes or -1 if an error occured
1029  */
1030 static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){
1031     int i, escape_count, si, di;
1032     uint8_t *temp;
1033     
1034     assert(length>=0);
1035     assert(dst_length>0);
1036     
1037     dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type;
1038
1039     if(length==0) return 1;
1040
1041     escape_count= 0;
1042     for(i=0; i<length; i+=2){
1043         if(src[i]) continue;
1044         if(i>0 && src[i-1]==0) 
1045             i--;
1046         if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1047             escape_count++;
1048             i+=2;
1049         }
1050     }
1051     
1052     if(escape_count==0){ 
1053         if(dst+1 != src)
1054             memcpy(dst+1, src, length);
1055         return length + 1;
1056     }
1057     
1058     if(length + escape_count + 1> dst_length)
1059         return -1;
1060
1061     //this should be damn rare (hopefully)
1062
1063     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count);
1064     temp= h->rbsp_buffer;
1065 //printf("encoding esc\n");
1066     
1067     si= 0;
1068     di= 0;
1069     while(si < length){
1070         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1071             temp[di++]= 0; si++;
1072             temp[di++]= 0; si++;
1073             temp[di++]= 3; 
1074             temp[di++]= src[si++];
1075         }
1076         else
1077             temp[di++]= src[si++];
1078     }
1079     memcpy(dst+1, temp, length+escape_count);
1080     
1081     assert(di == length+escape_count);
1082     
1083     return di + 1;
1084 }
1085
1086 /**
1087  * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4
1088  */
1089 static void encode_rbsp_trailing(PutBitContext *pb){
1090     int length;
1091     put_bits(pb, 1, 1);
1092     length= (-put_bits_count(pb))&7;
1093     if(length) put_bits(pb, length, 0);
1094 }
1095 #endif
1096
1097 /**
1098  * identifies the exact end of the bitstream
1099  * @return the length of the trailing, or 0 if damaged
1100  */
1101 static int decode_rbsp_trailing(uint8_t *src){
1102     int v= *src;
1103     int r;
1104
1105     tprintf("rbsp trailing %X\n", v);
1106
1107     for(r=1; r<9; r++){
1108         if(v&1) return r;
1109         v>>=1;
1110     }
1111     return 0;
1112 }
1113
1114 /**
1115  * idct tranforms the 16 dc values and dequantize them.
1116  * @param qp quantization parameter
1117  */
1118 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
1119     const int qmul= dequant_coeff[qp][0];
1120 #define stride 16
1121     int i;
1122     int temp[16]; //FIXME check if this is a good idea
1123     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
1124     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1125
1126 //memset(block, 64, 2*256);
1127 //return;
1128     for(i=0; i<4; i++){
1129         const int offset= y_offset[i];
1130         const int z0= block[offset+stride*0] + block[offset+stride*4];
1131         const int z1= block[offset+stride*0] - block[offset+stride*4];
1132         const int z2= block[offset+stride*1] - block[offset+stride*5];
1133         const int z3= block[offset+stride*1] + block[offset+stride*5];
1134
1135         temp[4*i+0]= z0+z3;
1136         temp[4*i+1]= z1+z2;
1137         temp[4*i+2]= z1-z2;
1138         temp[4*i+3]= z0-z3;
1139     }
1140
1141     for(i=0; i<4; i++){
1142         const int offset= x_offset[i];
1143         const int z0= temp[4*0+i] + temp[4*2+i];
1144         const int z1= temp[4*0+i] - temp[4*2+i];
1145         const int z2= temp[4*1+i] - temp[4*3+i];
1146         const int z3= temp[4*1+i] + temp[4*3+i];
1147
1148         block[stride*0 +offset]= ((z0 + z3)*qmul + 2)>>2; //FIXME think about merging this into decode_resdual
1149         block[stride*2 +offset]= ((z1 + z2)*qmul + 2)>>2;
1150         block[stride*8 +offset]= ((z1 - z2)*qmul + 2)>>2;
1151         block[stride*10+offset]= ((z0 - z3)*qmul + 2)>>2;
1152     }
1153 }
1154
1155 #if 0
1156 /**
1157  * dct tranforms the 16 dc values.
1158  * @param qp quantization parameter ??? FIXME
1159  */
1160 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
1161 //    const int qmul= dequant_coeff[qp][0];
1162     int i;
1163     int temp[16]; //FIXME check if this is a good idea
1164     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
1165     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1166
1167     for(i=0; i<4; i++){
1168         const int offset= y_offset[i];
1169         const int z0= block[offset+stride*0] + block[offset+stride*4];
1170         const int z1= block[offset+stride*0] - block[offset+stride*4];
1171         const int z2= block[offset+stride*1] - block[offset+stride*5];
1172         const int z3= block[offset+stride*1] + block[offset+stride*5];
1173
1174         temp[4*i+0]= z0+z3;
1175         temp[4*i+1]= z1+z2;
1176         temp[4*i+2]= z1-z2;
1177         temp[4*i+3]= z0-z3;
1178     }
1179
1180     for(i=0; i<4; i++){
1181         const int offset= x_offset[i];
1182         const int z0= temp[4*0+i] + temp[4*2+i];
1183         const int z1= temp[4*0+i] - temp[4*2+i];
1184         const int z2= temp[4*1+i] - temp[4*3+i];
1185         const int z3= temp[4*1+i] + temp[4*3+i];
1186
1187         block[stride*0 +offset]= (z0 + z3)>>1;
1188         block[stride*2 +offset]= (z1 + z2)>>1;
1189         block[stride*8 +offset]= (z1 - z2)>>1;
1190         block[stride*10+offset]= (z0 - z3)>>1;
1191     }
1192 }
1193 #endif
1194
1195 #undef xStride
1196 #undef stride
1197
1198 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp){
1199     const int qmul= dequant_coeff[qp][0];
1200     const int stride= 16*2;
1201     const int xStride= 16;
1202     int a,b,c,d,e;
1203
1204     a= block[stride*0 + xStride*0];
1205     b= block[stride*0 + xStride*1];
1206     c= block[stride*1 + xStride*0];
1207     d= block[stride*1 + xStride*1];
1208
1209     e= a-b;
1210     a= a+b;
1211     b= c-d;
1212     c= c+d;
1213
1214     block[stride*0 + xStride*0]= ((a+c)*qmul + 0)>>1;
1215     block[stride*0 + xStride*1]= ((e+b)*qmul + 0)>>1;
1216     block[stride*1 + xStride*0]= ((a-c)*qmul + 0)>>1;
1217     block[stride*1 + xStride*1]= ((e-b)*qmul + 0)>>1;
1218 }
1219
1220 #if 0
1221 static void chroma_dc_dct_c(DCTELEM *block){
1222     const int stride= 16*2;
1223     const int xStride= 16;
1224     int a,b,c,d,e;
1225
1226     a= block[stride*0 + xStride*0];
1227     b= block[stride*0 + xStride*1];
1228     c= block[stride*1 + xStride*0];
1229     d= block[stride*1 + xStride*1];
1230
1231     e= a-b;
1232     a= a+b;
1233     b= c-d;
1234     c= c+d;
1235
1236     block[stride*0 + xStride*0]= (a+c);
1237     block[stride*0 + xStride*1]= (e+b);
1238     block[stride*1 + xStride*0]= (a-c);
1239     block[stride*1 + xStride*1]= (e-b);
1240 }
1241 #endif
1242
1243 /**
1244  * gets the chroma qp.
1245  */
1246 static inline int get_chroma_qp(H264Context *h, int qscale){
1247     
1248     return chroma_qp[clip(qscale + h->pps.chroma_qp_index_offset, 0, 51)];
1249 }
1250
1251
1252 /**
1253  *
1254  */
1255 static void h264_add_idct_c(uint8_t *dst, DCTELEM *block, int stride){
1256     int i;
1257     uint8_t *cm = cropTbl + MAX_NEG_CROP;
1258
1259     block[0] += 32;
1260 #if 1
1261     for(i=0; i<4; i++){
1262         const int z0=  block[i + 4*0]     +  block[i + 4*2];
1263         const int z1=  block[i + 4*0]     -  block[i + 4*2];
1264         const int z2= (block[i + 4*1]>>1) -  block[i + 4*3];
1265         const int z3=  block[i + 4*1]     + (block[i + 4*3]>>1);
1266
1267         block[i + 4*0]= z0 + z3;
1268         block[i + 4*1]= z1 + z2;
1269         block[i + 4*2]= z1 - z2;
1270         block[i + 4*3]= z0 - z3;
1271     }
1272
1273     for(i=0; i<4; i++){
1274         const int z0=  block[0 + 4*i]     +  block[2 + 4*i];
1275         const int z1=  block[0 + 4*i]     -  block[2 + 4*i];
1276         const int z2= (block[1 + 4*i]>>1) -  block[3 + 4*i];
1277         const int z3=  block[1 + 4*i]     + (block[3 + 4*i]>>1);
1278
1279         dst[0 + i*stride]= cm[ dst[0 + i*stride] + ((z0 + z3) >> 6) ];
1280         dst[1 + i*stride]= cm[ dst[1 + i*stride] + ((z1 + z2) >> 6) ];
1281         dst[2 + i*stride]= cm[ dst[2 + i*stride] + ((z1 - z2) >> 6) ];
1282         dst[3 + i*stride]= cm[ dst[3 + i*stride] + ((z0 - z3) >> 6) ];
1283     }
1284 #else
1285     for(i=0; i<4; i++){
1286         const int z0=  block[0 + 4*i]     +  block[2 + 4*i];
1287         const int z1=  block[0 + 4*i]     -  block[2 + 4*i];
1288         const int z2= (block[1 + 4*i]>>1) -  block[3 + 4*i];
1289         const int z3=  block[1 + 4*i]     + (block[3 + 4*i]>>1);
1290
1291         block[0 + 4*i]= z0 + z3;
1292         block[1 + 4*i]= z1 + z2;
1293         block[2 + 4*i]= z1 - z2;
1294         block[3 + 4*i]= z0 - z3;
1295     }
1296
1297     for(i=0; i<4; i++){
1298         const int z0=  block[i + 4*0]     +  block[i + 4*2];
1299         const int z1=  block[i + 4*0]     -  block[i + 4*2];
1300         const int z2= (block[i + 4*1]>>1) -  block[i + 4*3];
1301         const int z3=  block[i + 4*1]     + (block[i + 4*3]>>1);
1302
1303         dst[i + 0*stride]= cm[ dst[i + 0*stride] + ((z0 + z3) >> 6) ];
1304         dst[i + 1*stride]= cm[ dst[i + 1*stride] + ((z1 + z2) >> 6) ];
1305         dst[i + 2*stride]= cm[ dst[i + 2*stride] + ((z1 - z2) >> 6) ];
1306         dst[i + 3*stride]= cm[ dst[i + 3*stride] + ((z0 - z3) >> 6) ];
1307     }
1308 #endif
1309 }
1310
1311 #if 0
1312 static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){
1313     int i;
1314     //FIXME try int temp instead of block
1315     
1316     for(i=0; i<4; i++){
1317         const int d0= src1[0 + i*stride] - src2[0 + i*stride];
1318         const int d1= src1[1 + i*stride] - src2[1 + i*stride];
1319         const int d2= src1[2 + i*stride] - src2[2 + i*stride];
1320         const int d3= src1[3 + i*stride] - src2[3 + i*stride];
1321         const int z0= d0 + d3;
1322         const int z3= d0 - d3;
1323         const int z1= d1 + d2;
1324         const int z2= d1 - d2;
1325         
1326         block[0 + 4*i]=   z0 +   z1;
1327         block[1 + 4*i]= 2*z3 +   z2;
1328         block[2 + 4*i]=   z0 -   z1;
1329         block[3 + 4*i]=   z3 - 2*z2;
1330     }    
1331
1332     for(i=0; i<4; i++){
1333         const int z0= block[0*4 + i] + block[3*4 + i];
1334         const int z3= block[0*4 + i] - block[3*4 + i];
1335         const int z1= block[1*4 + i] + block[2*4 + i];
1336         const int z2= block[1*4 + i] - block[2*4 + i];
1337         
1338         block[0*4 + i]=   z0 +   z1;
1339         block[1*4 + i]= 2*z3 +   z2;
1340         block[2*4 + i]=   z0 -   z1;
1341         block[3*4 + i]=   z3 - 2*z2;
1342     }
1343 }
1344 #endif
1345
1346 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, iam not sure, its very close
1347 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)
1348 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){
1349     int i;
1350     const int * const quant_table= quant_coeff[qscale];
1351     const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
1352     const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
1353     const unsigned int threshold2= (threshold1<<1);
1354     int last_non_zero;
1355
1356     if(seperate_dc){
1357         if(qscale<=18){
1358             //avoid overflows
1359             const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
1360             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
1361             const unsigned int dc_threshold2= (dc_threshold1<<1);
1362
1363             int level= block[0]*quant_coeff[qscale+18][0];
1364             if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1365                 if(level>0){
1366                     level= (dc_bias + level)>>(QUANT_SHIFT-2);
1367                     block[0]= level;
1368                 }else{
1369                     level= (dc_bias - level)>>(QUANT_SHIFT-2);
1370                     block[0]= -level;
1371                 }
1372 //                last_non_zero = i;
1373             }else{
1374                 block[0]=0;
1375             }
1376         }else{
1377             const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
1378             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
1379             const unsigned int dc_threshold2= (dc_threshold1<<1);
1380
1381             int level= block[0]*quant_table[0];
1382             if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1383                 if(level>0){
1384                     level= (dc_bias + level)>>(QUANT_SHIFT+1);
1385                     block[0]= level;
1386                 }else{
1387                     level= (dc_bias - level)>>(QUANT_SHIFT+1);
1388                     block[0]= -level;
1389                 }
1390 //                last_non_zero = i;
1391             }else{
1392                 block[0]=0;
1393             }
1394         }
1395         last_non_zero= 0;
1396         i=1;
1397     }else{
1398         last_non_zero= -1;
1399         i=0;
1400     }
1401
1402     for(; i<16; i++){
1403         const int j= scantable[i];
1404         int level= block[j]*quant_table[j];
1405
1406 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
1407 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
1408         if(((unsigned)(level+threshold1))>threshold2){
1409             if(level>0){
1410                 level= (bias + level)>>QUANT_SHIFT;
1411                 block[j]= level;
1412             }else{
1413                 level= (bias - level)>>QUANT_SHIFT;
1414                 block[j]= -level;
1415             }
1416             last_non_zero = i;
1417         }else{
1418             block[j]=0;
1419         }
1420     }
1421
1422     return last_non_zero;
1423 }
1424
1425 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){
1426     const uint32_t a= ((uint32_t*)(src-stride))[0];
1427     ((uint32_t*)(src+0*stride))[0]= a;
1428     ((uint32_t*)(src+1*stride))[0]= a;
1429     ((uint32_t*)(src+2*stride))[0]= a;
1430     ((uint32_t*)(src+3*stride))[0]= a;
1431 }
1432
1433 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){
1434     ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;
1435     ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;
1436     ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;
1437     ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;
1438 }
1439
1440 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){
1441     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
1442                    + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
1443     
1444     ((uint32_t*)(src+0*stride))[0]= 
1445     ((uint32_t*)(src+1*stride))[0]= 
1446     ((uint32_t*)(src+2*stride))[0]= 
1447     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; 
1448 }
1449
1450 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){
1451     const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
1452     
1453     ((uint32_t*)(src+0*stride))[0]= 
1454     ((uint32_t*)(src+1*stride))[0]= 
1455     ((uint32_t*)(src+2*stride))[0]= 
1456     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; 
1457 }
1458
1459 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){
1460     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
1461     
1462     ((uint32_t*)(src+0*stride))[0]= 
1463     ((uint32_t*)(src+1*stride))[0]= 
1464     ((uint32_t*)(src+2*stride))[0]= 
1465     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; 
1466 }
1467
1468 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){
1469     ((uint32_t*)(src+0*stride))[0]= 
1470     ((uint32_t*)(src+1*stride))[0]= 
1471     ((uint32_t*)(src+2*stride))[0]= 
1472     ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;
1473 }
1474
1475
1476 #define LOAD_TOP_RIGHT_EDGE\
1477     const int t4= topright[0];\
1478     const int t5= topright[1];\
1479     const int t6= topright[2];\
1480     const int t7= topright[3];\
1481
1482 #define LOAD_LEFT_EDGE\
1483     const int l0= src[-1+0*stride];\
1484     const int l1= src[-1+1*stride];\
1485     const int l2= src[-1+2*stride];\
1486     const int l3= src[-1+3*stride];\
1487
1488 #define LOAD_TOP_EDGE\
1489     const int t0= src[ 0-1*stride];\
1490     const int t1= src[ 1-1*stride];\
1491     const int t2= src[ 2-1*stride];\
1492     const int t3= src[ 3-1*stride];\
1493
1494 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){
1495     const int lt= src[-1-1*stride];
1496     LOAD_TOP_EDGE
1497     LOAD_LEFT_EDGE
1498
1499     src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; 
1500     src[0+2*stride]=
1501     src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; 
1502     src[0+1*stride]=
1503     src[1+2*stride]=
1504     src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; 
1505     src[0+0*stride]=
1506     src[1+1*stride]=
1507     src[2+2*stride]=
1508     src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; 
1509     src[1+0*stride]=
1510     src[2+1*stride]=
1511     src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
1512     src[2+0*stride]=
1513     src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
1514     src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
1515 }
1516
1517 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){
1518     LOAD_TOP_EDGE    
1519     LOAD_TOP_RIGHT_EDGE    
1520 //    LOAD_LEFT_EDGE    
1521
1522     src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
1523     src[1+0*stride]=
1524     src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
1525     src[2+0*stride]=
1526     src[1+1*stride]=
1527     src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
1528     src[3+0*stride]=
1529     src[2+1*stride]=
1530     src[1+2*stride]=
1531     src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
1532     src[3+1*stride]=
1533     src[2+2*stride]=
1534     src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
1535     src[3+2*stride]=
1536     src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
1537     src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
1538 }
1539
1540 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){
1541     const int lt= src[-1-1*stride];
1542     LOAD_TOP_EDGE    
1543     LOAD_LEFT_EDGE    
1544     const __attribute__((unused)) int unu= l3;
1545
1546     src[0+0*stride]=
1547     src[1+2*stride]=(lt + t0 + 1)>>1;
1548     src[1+0*stride]=
1549     src[2+2*stride]=(t0 + t1 + 1)>>1;
1550     src[2+0*stride]=
1551     src[3+2*stride]=(t1 + t2 + 1)>>1;
1552     src[3+0*stride]=(t2 + t3 + 1)>>1;
1553     src[0+1*stride]=
1554     src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
1555     src[1+1*stride]=
1556     src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
1557     src[2+1*stride]=
1558     src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
1559     src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
1560     src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
1561     src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
1562 }
1563
1564 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){
1565     LOAD_TOP_EDGE    
1566     LOAD_TOP_RIGHT_EDGE    
1567     const __attribute__((unused)) int unu= t7;
1568
1569     src[0+0*stride]=(t0 + t1 + 1)>>1;
1570     src[1+0*stride]=
1571     src[0+2*stride]=(t1 + t2 + 1)>>1;
1572     src[2+0*stride]=
1573     src[1+2*stride]=(t2 + t3 + 1)>>1;
1574     src[3+0*stride]=
1575     src[2+2*stride]=(t3 + t4+ 1)>>1;
1576     src[3+2*stride]=(t4 + t5+ 1)>>1;
1577     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
1578     src[1+1*stride]=
1579     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
1580     src[2+1*stride]=
1581     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
1582     src[3+1*stride]=
1583     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
1584     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
1585 }
1586
1587 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){
1588     LOAD_LEFT_EDGE    
1589
1590     src[0+0*stride]=(l0 + l1 + 1)>>1;
1591     src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
1592     src[2+0*stride]=
1593     src[0+1*stride]=(l1 + l2 + 1)>>1;
1594     src[3+0*stride]=
1595     src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
1596     src[2+1*stride]=
1597     src[0+2*stride]=(l2 + l3 + 1)>>1;
1598     src[3+1*stride]=
1599     src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
1600     src[3+2*stride]=
1601     src[1+3*stride]=
1602     src[0+3*stride]=
1603     src[2+2*stride]=
1604     src[2+3*stride]=
1605     src[3+3*stride]=l3;
1606 }
1607     
1608 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){
1609     const int lt= src[-1-1*stride];
1610     LOAD_TOP_EDGE    
1611     LOAD_LEFT_EDGE    
1612     const __attribute__((unused)) int unu= t3;
1613
1614     src[0+0*stride]=
1615     src[2+1*stride]=(lt + l0 + 1)>>1;
1616     src[1+0*stride]=
1617     src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
1618     src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
1619     src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
1620     src[0+1*stride]=
1621     src[2+2*stride]=(l0 + l1 + 1)>>1;
1622     src[1+1*stride]=
1623     src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
1624     src[0+2*stride]=
1625     src[2+3*stride]=(l1 + l2+ 1)>>1;
1626     src[1+2*stride]=
1627     src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
1628     src[0+3*stride]=(l2 + l3 + 1)>>1;
1629     src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
1630 }
1631
1632 static void pred16x16_vertical_c(uint8_t *src, int stride){
1633     int i;
1634     const uint32_t a= ((uint32_t*)(src-stride))[0];
1635     const uint32_t b= ((uint32_t*)(src-stride))[1];
1636     const uint32_t c= ((uint32_t*)(src-stride))[2];
1637     const uint32_t d= ((uint32_t*)(src-stride))[3];
1638     
1639     for(i=0; i<16; i++){
1640         ((uint32_t*)(src+i*stride))[0]= a;
1641         ((uint32_t*)(src+i*stride))[1]= b;
1642         ((uint32_t*)(src+i*stride))[2]= c;
1643         ((uint32_t*)(src+i*stride))[3]= d;
1644     }
1645 }
1646
1647 static void pred16x16_horizontal_c(uint8_t *src, int stride){
1648     int i;
1649
1650     for(i=0; i<16; i++){
1651         ((uint32_t*)(src+i*stride))[0]=
1652         ((uint32_t*)(src+i*stride))[1]=
1653         ((uint32_t*)(src+i*stride))[2]=
1654         ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;
1655     }
1656 }
1657
1658 static void pred16x16_dc_c(uint8_t *src, int stride){
1659     int i, dc=0;
1660
1661     for(i=0;i<16; i++){
1662         dc+= src[-1+i*stride];
1663     }
1664     
1665     for(i=0;i<16; i++){
1666         dc+= src[i-stride];
1667     }
1668
1669     dc= 0x01010101*((dc + 16)>>5);
1670
1671     for(i=0; i<16; i++){
1672         ((uint32_t*)(src+i*stride))[0]=
1673         ((uint32_t*)(src+i*stride))[1]=
1674         ((uint32_t*)(src+i*stride))[2]=
1675         ((uint32_t*)(src+i*stride))[3]= dc;
1676     }
1677 }
1678
1679 static void pred16x16_left_dc_c(uint8_t *src, int stride){
1680     int i, dc=0;
1681
1682     for(i=0;i<16; i++){
1683         dc+= src[-1+i*stride];
1684     }
1685     
1686     dc= 0x01010101*((dc + 8)>>4);
1687
1688     for(i=0; i<16; i++){
1689         ((uint32_t*)(src+i*stride))[0]=
1690         ((uint32_t*)(src+i*stride))[1]=
1691         ((uint32_t*)(src+i*stride))[2]=
1692         ((uint32_t*)(src+i*stride))[3]= dc;
1693     }
1694 }
1695
1696 static void pred16x16_top_dc_c(uint8_t *src, int stride){
1697     int i, dc=0;
1698
1699     for(i=0;i<16; i++){
1700         dc+= src[i-stride];
1701     }
1702     dc= 0x01010101*((dc + 8)>>4);
1703
1704     for(i=0; i<16; i++){
1705         ((uint32_t*)(src+i*stride))[0]=
1706         ((uint32_t*)(src+i*stride))[1]=
1707         ((uint32_t*)(src+i*stride))[2]=
1708         ((uint32_t*)(src+i*stride))[3]= dc;
1709     }
1710 }
1711
1712 static void pred16x16_128_dc_c(uint8_t *src, int stride){
1713     int i;
1714
1715     for(i=0; i<16; i++){
1716         ((uint32_t*)(src+i*stride))[0]=
1717         ((uint32_t*)(src+i*stride))[1]=
1718         ((uint32_t*)(src+i*stride))[2]=
1719         ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;
1720     }
1721 }
1722
1723 static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
1724   int i, j, k;
1725   int a;
1726   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1727   const uint8_t * const src0 = src+7-stride;
1728   const uint8_t *src1 = src+8*stride-1;
1729   const uint8_t *src2 = src1-2*stride;      // == src+6*stride-1;
1730   int H = src0[1] - src0[-1];
1731   int V = src1[0] - src2[ 0];
1732   for(k=2; k<=8; ++k) {
1733     src1 += stride; src2 -= stride;
1734     H += k*(src0[k] - src0[-k]);
1735     V += k*(src1[0] - src2[ 0]);
1736   }
1737   if(svq3){
1738     H = ( 5*(H/4) ) / 16;
1739     V = ( 5*(V/4) ) / 16;
1740
1741     /* required for 100% accuracy */
1742     i = H; H = V; V = i;
1743   }else{
1744     H = ( 5*H+32 ) >> 6;
1745     V = ( 5*V+32 ) >> 6;
1746   }
1747
1748   a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
1749   for(j=16; j>0; --j) {
1750     int b = a;
1751     a += V;
1752     for(i=-16; i<0; i+=4) {
1753       src[16+i] = cm[ (b    ) >> 5 ];
1754       src[17+i] = cm[ (b+  H) >> 5 ];
1755       src[18+i] = cm[ (b+2*H) >> 5 ];
1756       src[19+i] = cm[ (b+3*H) >> 5 ];
1757       b += 4*H;
1758     }
1759     src += stride;
1760   }
1761 }
1762
1763 static void pred16x16_plane_c(uint8_t *src, int stride){
1764     pred16x16_plane_compat_c(src, stride, 0);
1765 }
1766
1767 static void pred8x8_vertical_c(uint8_t *src, int stride){
1768     int i;
1769     const uint32_t a= ((uint32_t*)(src-stride))[0];
1770     const uint32_t b= ((uint32_t*)(src-stride))[1];
1771     
1772     for(i=0; i<8; i++){
1773         ((uint32_t*)(src+i*stride))[0]= a;
1774         ((uint32_t*)(src+i*stride))[1]= b;
1775     }
1776 }
1777
1778 static void pred8x8_horizontal_c(uint8_t *src, int stride){
1779     int i;
1780
1781     for(i=0; i<8; i++){
1782         ((uint32_t*)(src+i*stride))[0]=
1783         ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;
1784     }
1785 }
1786
1787 static void pred8x8_128_dc_c(uint8_t *src, int stride){
1788     int i;
1789
1790     for(i=0; i<4; i++){
1791         ((uint32_t*)(src+i*stride))[0]= 
1792         ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
1793     }
1794     for(i=4; i<8; i++){
1795         ((uint32_t*)(src+i*stride))[0]= 
1796         ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
1797     }
1798 }
1799
1800 static void pred8x8_left_dc_c(uint8_t *src, int stride){
1801     int i;
1802     int dc0, dc2;
1803
1804     dc0=dc2=0;
1805     for(i=0;i<4; i++){
1806         dc0+= src[-1+i*stride];
1807         dc2+= src[-1+(i+4)*stride];
1808     }
1809     dc0= 0x01010101*((dc0 + 2)>>2);
1810     dc2= 0x01010101*((dc2 + 2)>>2);
1811
1812     for(i=0; i<4; i++){
1813         ((uint32_t*)(src+i*stride))[0]=
1814         ((uint32_t*)(src+i*stride))[1]= dc0;
1815     }
1816     for(i=4; i<8; i++){
1817         ((uint32_t*)(src+i*stride))[0]=
1818         ((uint32_t*)(src+i*stride))[1]= dc2;
1819     }
1820 }
1821
1822 static void pred8x8_top_dc_c(uint8_t *src, int stride){
1823     int i;
1824     int dc0, dc1;
1825
1826     dc0=dc1=0;
1827     for(i=0;i<4; i++){
1828         dc0+= src[i-stride];
1829         dc1+= src[4+i-stride];
1830     }
1831     dc0= 0x01010101*((dc0 + 2)>>2);
1832     dc1= 0x01010101*((dc1 + 2)>>2);
1833
1834     for(i=0; i<4; i++){
1835         ((uint32_t*)(src+i*stride))[0]= dc0;
1836         ((uint32_t*)(src+i*stride))[1]= dc1;
1837     }
1838     for(i=4; i<8; i++){
1839         ((uint32_t*)(src+i*stride))[0]= dc0;
1840         ((uint32_t*)(src+i*stride))[1]= dc1;
1841     }
1842 }
1843
1844
1845 static void pred8x8_dc_c(uint8_t *src, int stride){
1846     int i;
1847     int dc0, dc1, dc2, dc3;
1848
1849     dc0=dc1=dc2=0;
1850     for(i=0;i<4; i++){
1851         dc0+= src[-1+i*stride] + src[i-stride];
1852         dc1+= src[4+i-stride];
1853         dc2+= src[-1+(i+4)*stride];
1854     }
1855     dc3= 0x01010101*((dc1 + dc2 + 4)>>3);
1856     dc0= 0x01010101*((dc0 + 4)>>3);
1857     dc1= 0x01010101*((dc1 + 2)>>2);
1858     dc2= 0x01010101*((dc2 + 2)>>2);
1859
1860     for(i=0; i<4; i++){
1861         ((uint32_t*)(src+i*stride))[0]= dc0;
1862         ((uint32_t*)(src+i*stride))[1]= dc1;
1863     }
1864     for(i=4; i<8; i++){
1865         ((uint32_t*)(src+i*stride))[0]= dc2;
1866         ((uint32_t*)(src+i*stride))[1]= dc3;
1867     }
1868 }
1869
1870 static void pred8x8_plane_c(uint8_t *src, int stride){
1871   int j, k;
1872   int a;
1873   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1874   const uint8_t * const src0 = src+3-stride;
1875   const uint8_t *src1 = src+4*stride-1;
1876   const uint8_t *src2 = src1-2*stride;      // == src+2*stride-1;
1877   int H = src0[1] - src0[-1];
1878   int V = src1[0] - src2[ 0];
1879   for(k=2; k<=4; ++k) {
1880     src1 += stride; src2 -= stride;
1881     H += k*(src0[k] - src0[-k]);
1882     V += k*(src1[0] - src2[ 0]);
1883   }
1884   H = ( 17*H+16 ) >> 5;
1885   V = ( 17*V+16 ) >> 5;
1886
1887   a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
1888   for(j=8; j>0; --j) {
1889     int b = a;
1890     a += V;
1891     src[0] = cm[ (b    ) >> 5 ];
1892     src[1] = cm[ (b+  H) >> 5 ];
1893     src[2] = cm[ (b+2*H) >> 5 ];
1894     src[3] = cm[ (b+3*H) >> 5 ];
1895     src[4] = cm[ (b+4*H) >> 5 ];
1896     src[5] = cm[ (b+5*H) >> 5 ];
1897     src[6] = cm[ (b+6*H) >> 5 ];
1898     src[7] = cm[ (b+7*H) >> 5 ];
1899     src += stride;
1900   }
1901 }
1902
1903 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
1904                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1905                            int src_x_offset, int src_y_offset,
1906                            qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
1907     MpegEncContext * const s = &h->s;
1908     const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
1909     const int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
1910     const int luma_xy= (mx&3) + ((my&3)<<2);
1911     uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*s->linesize;
1912     uint8_t * src_cb= pic->data[1] + (mx>>3) + (my>>3)*s->uvlinesize;
1913     uint8_t * src_cr= pic->data[2] + (mx>>3) + (my>>3)*s->uvlinesize;
1914     int extra_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; //FIXME increase edge?, IMHO not worth it
1915     int extra_height= extra_width;
1916     int emu=0;
1917     const int full_mx= mx>>2;
1918     const int full_my= my>>2;
1919     
1920     assert(pic->data[0]);
1921     
1922     if(mx&7) extra_width -= 3;
1923     if(my&7) extra_height -= 3;
1924     
1925     if(   full_mx < 0-extra_width 
1926        || full_my < 0-extra_height 
1927        || full_mx + 16/*FIXME*/ > s->width + extra_width 
1928        || full_my + 16/*FIXME*/ > s->height + extra_height){
1929         ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*s->linesize, s->linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, s->width, s->height);
1930             src_y= s->edge_emu_buffer + 2 + 2*s->linesize;
1931         emu=1;
1932     }
1933     
1934     qpix_op[luma_xy](dest_y, src_y, s->linesize); //FIXME try variable height perhaps?
1935     if(!square){
1936         qpix_op[luma_xy](dest_y + delta, src_y + delta, s->linesize);
1937     }
1938     
1939     if(s->flags&CODEC_FLAG_GRAY) return;
1940     
1941     if(emu){
1942         ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), s->width>>1, s->height>>1);
1943             src_cb= s->edge_emu_buffer;
1944     }
1945     chroma_op(dest_cb, src_cb, s->uvlinesize, chroma_height, mx&7, my&7);
1946
1947     if(emu){
1948         ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), s->width>>1, s->height>>1);
1949             src_cr= s->edge_emu_buffer;
1950     }
1951     chroma_op(dest_cr, src_cr, s->uvlinesize, chroma_height, mx&7, my&7);
1952 }
1953
1954 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
1955                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1956                            int x_offset, int y_offset,
1957                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1958                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1959                            int list0, int list1){
1960     MpegEncContext * const s = &h->s;
1961     qpel_mc_func *qpix_op=  qpix_put;
1962     h264_chroma_mc_func chroma_op= chroma_put;
1963     
1964     dest_y  += 2*x_offset + 2*y_offset*s->  linesize;
1965     dest_cb +=   x_offset +   y_offset*s->uvlinesize;
1966     dest_cr +=   x_offset +   y_offset*s->uvlinesize;
1967     x_offset += 8*s->mb_x;
1968     y_offset += 8*s->mb_y;
1969     
1970     if(list0){
1971         Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
1972         mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
1973                            dest_y, dest_cb, dest_cr, x_offset, y_offset,
1974                            qpix_op, chroma_op);
1975
1976         qpix_op=  qpix_avg;
1977         chroma_op= chroma_avg;
1978     }
1979
1980     if(list1){
1981         Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
1982         mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
1983                            dest_y, dest_cb, dest_cr, x_offset, y_offset,
1984                            qpix_op, chroma_op);
1985     }
1986 }
1987
1988 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1989                       qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
1990                       qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg)){
1991     MpegEncContext * const s = &h->s;
1992     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
1993     const int mb_type= s->current_picture.mb_type[mb_xy];
1994     
1995     assert(IS_INTER(mb_type));
1996     
1997     if(IS_16X16(mb_type)){
1998         mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
1999                 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
2000                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2001     }else if(IS_16X8(mb_type)){
2002         mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
2003                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2004                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2005         mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
2006                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2007                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2008     }else if(IS_8X16(mb_type)){
2009         mc_part(h, 0, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 0, 0,
2010                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2011                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2012         mc_part(h, 4, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 4, 0,
2013                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2014                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2015     }else{
2016         int i;
2017         
2018         assert(IS_8X8(mb_type));
2019
2020         for(i=0; i<4; i++){
2021             const int sub_mb_type= h->sub_mb_type[i];
2022             const int n= 4*i;
2023             int x_offset= (i&1)<<2;
2024             int y_offset= (i&2)<<1;
2025
2026             if(IS_SUB_8X8(sub_mb_type)){
2027                 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2028                     qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2029                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2030             }else if(IS_SUB_8X4(sub_mb_type)){
2031                 mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2032                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
2033                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2034                 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
2035                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
2036                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2037             }else if(IS_SUB_4X8(sub_mb_type)){
2038                 mc_part(h, n  , 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2039                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2040                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2041                 mc_part(h, n+1, 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
2042                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2043                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2044             }else{
2045                 int j;
2046                 assert(IS_SUB_4X4(sub_mb_type));
2047                 for(j=0; j<4; j++){
2048                     int sub_x_offset= x_offset + 2*(j&1);
2049                     int sub_y_offset= y_offset +   (j&2);
2050                     mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
2051                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2052                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2053                 }
2054             }
2055         }
2056     }
2057 }
2058
2059 static void decode_init_vlc(H264Context *h){
2060     static int done = 0;
2061
2062     if (!done) {
2063         int i;
2064         done = 1;
2065
2066         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, 
2067                  &chroma_dc_coeff_token_len [0], 1, 1,
2068                  &chroma_dc_coeff_token_bits[0], 1, 1);
2069
2070         for(i=0; i<4; i++){
2071             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, 
2072                      &coeff_token_len [i][0], 1, 1,
2073                      &coeff_token_bits[i][0], 1, 1);
2074         }
2075
2076         for(i=0; i<3; i++){
2077             init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
2078                      &chroma_dc_total_zeros_len [i][0], 1, 1,
2079                      &chroma_dc_total_zeros_bits[i][0], 1, 1);
2080         }
2081         for(i=0; i<15; i++){
2082             init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, 
2083                      &total_zeros_len [i][0], 1, 1,
2084                      &total_zeros_bits[i][0], 1, 1);
2085         }
2086
2087         for(i=0; i<6; i++){
2088             init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, 
2089                      &run_len [i][0], 1, 1,
2090                      &run_bits[i][0], 1, 1);
2091         }
2092         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, 
2093                  &run_len [6][0], 1, 1,
2094                  &run_bits[6][0], 1, 1);
2095     }
2096 }
2097
2098 /**
2099  * Sets the intra prediction function pointers.
2100  */
2101 static void init_pred_ptrs(H264Context *h){
2102 //    MpegEncContext * const s = &h->s;
2103
2104     h->pred4x4[VERT_PRED           ]= pred4x4_vertical_c;
2105     h->pred4x4[HOR_PRED            ]= pred4x4_horizontal_c;
2106     h->pred4x4[DC_PRED             ]= pred4x4_dc_c;
2107     h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;
2108     h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;
2109     h->pred4x4[VERT_RIGHT_PRED     ]= pred4x4_vertical_right_c;
2110     h->pred4x4[HOR_DOWN_PRED       ]= pred4x4_horizontal_down_c;
2111     h->pred4x4[VERT_LEFT_PRED      ]= pred4x4_vertical_left_c;
2112     h->pred4x4[HOR_UP_PRED         ]= pred4x4_horizontal_up_c;
2113     h->pred4x4[LEFT_DC_PRED        ]= pred4x4_left_dc_c;
2114     h->pred4x4[TOP_DC_PRED         ]= pred4x4_top_dc_c;
2115     h->pred4x4[DC_128_PRED         ]= pred4x4_128_dc_c;
2116
2117     h->pred8x8[DC_PRED8x8     ]= pred8x8_dc_c;
2118     h->pred8x8[VERT_PRED8x8   ]= pred8x8_vertical_c;
2119     h->pred8x8[HOR_PRED8x8    ]= pred8x8_horizontal_c;
2120     h->pred8x8[PLANE_PRED8x8  ]= pred8x8_plane_c;
2121     h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;
2122     h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;
2123     h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;
2124
2125     h->pred16x16[DC_PRED8x8     ]= pred16x16_dc_c;
2126     h->pred16x16[VERT_PRED8x8   ]= pred16x16_vertical_c;
2127     h->pred16x16[HOR_PRED8x8    ]= pred16x16_horizontal_c;
2128     h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_c;
2129     h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;
2130     h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;
2131     h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;
2132 }
2133
2134 static void free_tables(H264Context *h){
2135     av_freep(&h->intra4x4_pred_mode);
2136     av_freep(&h->chroma_pred_mode_table);
2137     av_freep(&h->cbp_table);
2138     av_freep(&h->non_zero_count);
2139     av_freep(&h->slice_table_base);
2140     av_freep(&h->top_border);
2141     h->slice_table= NULL;
2142
2143     av_freep(&h->mb2b_xy);
2144     av_freep(&h->mb2b8_xy);
2145 }
2146
2147 /**
2148  * allocates tables.
2149  * needs widzh/height
2150  */
2151 static int alloc_tables(H264Context *h){
2152     MpegEncContext * const s = &h->s;
2153     const int big_mb_num= s->mb_stride * (s->mb_height+1);
2154     int x,y;
2155
2156     CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8  * sizeof(uint8_t))
2157
2158     CHECKED_ALLOCZ(h->non_zero_count    , big_mb_num * 16 * sizeof(uint8_t))
2159     CHECKED_ALLOCZ(h->slice_table_base  , big_mb_num * sizeof(uint8_t))
2160     CHECKED_ALLOCZ(h->top_border       , s->mb_width * (16+8+8) * sizeof(uint8_t))
2161
2162     if( h->pps.cabac ) {
2163         CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
2164         CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
2165     } else {
2166         h->chroma_pred_mode_table = NULL;
2167         h->cbp_table = NULL;
2168     }
2169
2170     memset(h->slice_table_base, -1, big_mb_num  * sizeof(uint8_t));
2171     h->slice_table= h->slice_table_base + s->mb_stride + 1;
2172
2173     CHECKED_ALLOCZ(h->mb2b_xy  , big_mb_num * sizeof(uint16_t));
2174     CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint16_t));
2175     for(y=0; y<s->mb_height; y++){
2176         for(x=0; x<s->mb_width; x++){
2177             const int mb_xy= x + y*s->mb_stride;
2178             const int b_xy = 4*x + 4*y*h->b_stride;
2179             const int b8_xy= 2*x + 2*y*h->b8_stride;
2180         
2181             h->mb2b_xy [mb_xy]= b_xy;
2182             h->mb2b8_xy[mb_xy]= b8_xy;
2183         }
2184     }
2185     
2186     return 0;
2187 fail:
2188     free_tables(h);
2189     return -1;
2190 }
2191
2192 static void common_init(H264Context *h){
2193     MpegEncContext * const s = &h->s;
2194
2195     s->width = s->avctx->width;
2196     s->height = s->avctx->height;
2197     s->codec_id= s->avctx->codec->id;
2198     
2199     init_pred_ptrs(h);
2200
2201     s->unrestricted_mv=1;
2202     s->decode=1; //FIXME
2203 }
2204
2205 static int decode_init(AVCodecContext *avctx){
2206     H264Context *h= avctx->priv_data;
2207     MpegEncContext * const s = &h->s;
2208
2209     MPV_decode_defaults(s);
2210     
2211     s->avctx = avctx;
2212     common_init(h);
2213
2214     s->out_format = FMT_H264;
2215     s->workaround_bugs= avctx->workaround_bugs;
2216
2217     // set defaults
2218 //    s->decode_mb= ff_h263_decode_mb;
2219     s->low_delay= 1;
2220     avctx->pix_fmt= PIX_FMT_YUV420P;
2221
2222     decode_init_vlc(h);
2223     
2224     return 0;
2225 }
2226
2227 static void frame_start(H264Context *h){
2228     MpegEncContext * const s = &h->s;
2229     int i;
2230
2231     MPV_frame_start(s, s->avctx);
2232     ff_er_frame_start(s);
2233     h->mmco_index=0;
2234
2235     assert(s->linesize && s->uvlinesize);
2236
2237     for(i=0; i<16; i++){
2238         h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
2239         h->chroma_subblock_offset[i]= 2*((scan8[i] - scan8[0])&7) + 2*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2240     }
2241     for(i=0; i<4; i++){
2242         h->block_offset[16+i]=
2243         h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2244     }
2245
2246 //    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
2247 }
2248
2249 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
2250     MpegEncContext * const s = &h->s;
2251     int i;
2252     
2253     src_y  -=   linesize;
2254     src_cb -= uvlinesize;
2255     src_cr -= uvlinesize;
2256
2257     h->left_border[0]= h->top_border[s->mb_x][15];
2258     for(i=1; i<17; i++){
2259         h->left_border[i]= src_y[15+i*  linesize];
2260     }
2261     
2262     *(uint64_t*)(h->top_border[s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);
2263     *(uint64_t*)(h->top_border[s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
2264
2265     if(!(s->flags&CODEC_FLAG_GRAY)){
2266         h->left_border[17  ]= h->top_border[s->mb_x][16+7];
2267         h->left_border[17+9]= h->top_border[s->mb_x][24+7];
2268         for(i=1; i<9; i++){
2269             h->left_border[i+17  ]= src_cb[7+i*uvlinesize];
2270             h->left_border[i+17+9]= src_cr[7+i*uvlinesize];
2271         }
2272         *(uint64_t*)(h->top_border[s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
2273         *(uint64_t*)(h->top_border[s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
2274     }
2275 }
2276
2277 static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){
2278     MpegEncContext * const s = &h->s;
2279     int temp8, i;
2280     uint64_t temp64;
2281
2282     src_y  -=   linesize + 1;
2283     src_cb -= uvlinesize + 1;
2284     src_cr -= uvlinesize + 1;
2285
2286 #define XCHG(a,b,t,xchg)\
2287 t= a;\
2288 if(xchg)\
2289     a= b;\
2290 b= t;
2291     
2292     for(i=0; i<17; i++){
2293         XCHG(h->left_border[i     ], src_y [i*  linesize], temp8, xchg);
2294     }
2295     
2296     XCHG(*(uint64_t*)(h->top_border[s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
2297     XCHG(*(uint64_t*)(h->top_border[s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
2298
2299     if(!(s->flags&CODEC_FLAG_GRAY)){
2300         for(i=0; i<9; i++){
2301             XCHG(h->left_border[i+17  ], src_cb[i*uvlinesize], temp8, xchg);
2302             XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);
2303         }
2304         XCHG(*(uint64_t*)(h->top_border[s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
2305         XCHG(*(uint64_t*)(h->top_border[s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
2306     }
2307 }
2308
2309 static void hl_decode_mb(H264Context *h){
2310     MpegEncContext * const s = &h->s;
2311     const int mb_x= s->mb_x;
2312     const int mb_y= s->mb_y;
2313     const int mb_xy= mb_x + mb_y*s->mb_stride;
2314     const int mb_type= s->current_picture.mb_type[mb_xy];
2315     uint8_t  *dest_y, *dest_cb, *dest_cr;
2316     int linesize, uvlinesize /*dct_offset*/;
2317     int i;
2318
2319     if(!s->decode)
2320         return;
2321
2322     if(s->mb_skiped){
2323     }
2324
2325     dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
2326     dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2327     dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2328
2329     if (h->mb_field_decoding_flag) {
2330         linesize = s->linesize * 2;
2331         uvlinesize = s->uvlinesize * 2;
2332         if(mb_y&1){ //FIXME move out of this func?
2333             dest_y -= s->linesize*15;
2334             dest_cb-= s->linesize*7;
2335             dest_cr-= s->linesize*7;
2336         }
2337     } else {
2338         linesize = s->linesize;
2339         uvlinesize = s->uvlinesize;
2340 //        dct_offset = s->linesize * 16;
2341     }
2342
2343     if(IS_INTRA(mb_type)){
2344         if(h->deblocking_filter)
2345             xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
2346
2347         if(!(s->flags&CODEC_FLAG_GRAY)){
2348             h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
2349             h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
2350         }
2351
2352         if(IS_INTRA4x4(mb_type)){
2353             if(!s->encoding){
2354                 for(i=0; i<16; i++){
2355                     uint8_t * const ptr= dest_y + h->block_offset[i];
2356                     uint8_t *topright= ptr + 4 - linesize;
2357                     const int topright_avail= (h->topright_samples_available<<i)&0x8000;
2358                     const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2359                     int tr;
2360
2361                     if(!topright_avail){
2362                         tr= ptr[3 - linesize]*0x01010101;
2363                         topright= (uint8_t*) &tr;
2364                     }else if(i==5 && h->deblocking_filter){
2365                         tr= *(uint32_t*)h->top_border[mb_x+1];
2366                         topright= (uint8_t*) &tr;
2367                     }
2368
2369                     h->pred4x4[ dir ](ptr, topright, linesize);
2370                     if(h->non_zero_count_cache[ scan8[i] ]){
2371                         if(s->codec_id == CODEC_ID_H264)
2372                             h264_add_idct_c(ptr, h->mb + i*16, linesize);
2373                         else
2374                             svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
2375                     }
2376                 }
2377             }
2378         }else{
2379             h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
2380             if(s->codec_id == CODEC_ID_H264)
2381                 h264_luma_dc_dequant_idct_c(h->mb, s->qscale);
2382             else
2383                 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
2384         }
2385         if(h->deblocking_filter)
2386             xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
2387     }else if(s->codec_id == CODEC_ID_H264){
2388         hl_motion(h, dest_y, dest_cb, dest_cr,
2389                   s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab, 
2390                   s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab);
2391     }
2392
2393
2394     if(!IS_INTRA4x4(mb_type)){
2395         if(s->codec_id == CODEC_ID_H264){
2396             for(i=0; i<16; i++){
2397                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
2398                     uint8_t * const ptr= dest_y + h->block_offset[i];
2399                     h264_add_idct_c(ptr, h->mb + i*16, linesize);
2400                 }
2401             }
2402         }else{
2403             for(i=0; i<16; i++){
2404                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
2405                     uint8_t * const ptr= dest_y + h->block_offset[i];
2406                     svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
2407                 }
2408             }
2409         }
2410     }
2411
2412     if(!(s->flags&CODEC_FLAG_GRAY)){
2413         chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp);
2414         chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp);
2415         if(s->codec_id == CODEC_ID_H264){
2416             for(i=16; i<16+4; i++){
2417                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2418                     uint8_t * const ptr= dest_cb + h->block_offset[i];
2419                     h264_add_idct_c(ptr, h->mb + i*16, uvlinesize);
2420                 }
2421             }
2422             for(i=20; i<20+4; i++){
2423                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2424                     uint8_t * const ptr= dest_cr + h->block_offset[i];
2425                     h264_add_idct_c(ptr, h->mb + i*16, uvlinesize);
2426                 }
2427             }
2428         }else{
2429             for(i=16; i<16+4; i++){
2430                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2431                     uint8_t * const ptr= dest_cb + h->block_offset[i];
2432                     svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2433                 }
2434             }
2435             for(i=20; i<20+4; i++){
2436                 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2437                     uint8_t * const ptr= dest_cr + h->block_offset[i];
2438                     svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2439                 }
2440             }
2441         }
2442     }
2443     if(h->deblocking_filter) {
2444         backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2445         filter_mb(h, mb_x, mb_y, dest_y, dest_cb, dest_cr);
2446     }
2447 }
2448
2449 /**
2450  * fills the default_ref_list.
2451  */
2452 static int fill_default_ref_list(H264Context *h){
2453     MpegEncContext * const s = &h->s;
2454     int i;
2455     Picture sorted_short_ref[16];
2456     
2457     if(h->slice_type==B_TYPE){
2458         int out_i;
2459         int limit= -1;
2460
2461         for(out_i=0; out_i<h->short_ref_count; out_i++){
2462             int best_i=-1;
2463             int best_poc=-1;
2464
2465             for(i=0; i<h->short_ref_count; i++){
2466                 const int poc= h->short_ref[i]->poc;
2467                 if(poc > limit && poc < best_poc){
2468                     best_poc= poc;
2469                     best_i= i;
2470                 }
2471             }
2472             
2473             assert(best_i != -1);
2474             
2475             limit= best_poc;
2476             sorted_short_ref[out_i]= *h->short_ref[best_i];
2477         }
2478     }
2479
2480     if(s->picture_structure == PICT_FRAME){
2481         if(h->slice_type==B_TYPE){
2482             const int current_poc= s->current_picture_ptr->poc;
2483             int list;
2484
2485             for(list=0; list<2; list++){
2486                 int index=0;
2487
2488                 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++){
2489                     const int i2= list ? h->short_ref_count - i - 1 : i;
2490                     const int poc= sorted_short_ref[i2].poc;
2491                     
2492                     if(sorted_short_ref[i2].reference != 3) continue; //FIXME refernce field shit
2493
2494                     if((list==1 && poc > current_poc) || (list==0 && poc < current_poc)){
2495                         h->default_ref_list[list][index  ]= sorted_short_ref[i2];
2496                         h->default_ref_list[list][index++].pic_id= sorted_short_ref[i2].frame_num;
2497                     }
2498                 }
2499
2500                 for(i=0; i<h->long_ref_count && index < h->ref_count[ list ]; i++){
2501                     if(h->long_ref[i]->reference != 3) continue;
2502
2503                     h->default_ref_list[ list ][index  ]= *h->long_ref[i];
2504                     h->default_ref_list[ list ][index++].pic_id= i;;
2505                 }
2506                 
2507                 if(h->long_ref_count > 1 && h->short_ref_count==0){
2508                     Picture temp= h->default_ref_list[1][0];
2509                     h->default_ref_list[1][0] = h->default_ref_list[1][1];
2510                     h->default_ref_list[1][0] = temp;
2511                 }
2512
2513                 if(index < h->ref_count[ list ])
2514                     memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));
2515             }
2516         }else{
2517             int index=0;
2518             for(i=0; i<h->short_ref_count && index < h->ref_count[0]; i++){
2519                 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit
2520                 h->default_ref_list[0][index  ]= *h->short_ref[i];
2521                 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;
2522             }
2523             for(i=0; i<h->long_ref_count && index < h->ref_count[0]; i++){
2524                 if(h->long_ref[i]->reference != 3) continue;
2525                 h->default_ref_list[0][index  ]= *h->long_ref[i];
2526                 h->default_ref_list[0][index++].pic_id= i;;
2527             }
2528             if(index < h->ref_count[0])
2529                 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));
2530         }
2531     }else{ //FIELD
2532         if(h->slice_type==B_TYPE){
2533         }else{
2534             //FIXME second field balh
2535         }
2536     }
2537     return 0;
2538 }
2539
2540 static int decode_ref_pic_list_reordering(H264Context *h){
2541     MpegEncContext * const s = &h->s;
2542     int list;
2543     
2544     if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move beofre func
2545     
2546     for(list=0; list<2; list++){
2547         memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
2548
2549         if(get_bits1(&s->gb)){
2550             int pred= h->curr_pic_num;
2551             int index;
2552
2553             for(index=0; ; index++){
2554                 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
2555                 int pic_id;
2556                 int i;
2557                 
2558                 
2559                 if(index >= h->ref_count[list]){
2560                     av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
2561                     return -1;
2562                 }
2563                 
2564                 if(reordering_of_pic_nums_idc<3){
2565                     if(reordering_of_pic_nums_idc<2){
2566                         const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
2567
2568                         if(abs_diff_pic_num >= h->max_pic_num){
2569                             av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
2570                             return -1;
2571                         }
2572
2573                         if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
2574                         else                                pred+= abs_diff_pic_num;
2575                         pred &= h->max_pic_num - 1;
2576                     
2577                         for(i= h->ref_count[list]-1; i>=index; i--){
2578                             if(h->ref_list[list][i].pic_id == pred && h->ref_list[list][i].long_ref==0)
2579                                 break;
2580                         }
2581                     }else{
2582                         pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
2583
2584                         for(i= h->ref_count[list]-1; i>=index; i--){
2585                             if(h->ref_list[list][i].pic_id == pic_id && h->ref_list[list][i].long_ref==1)
2586                                 break;
2587                         }
2588                     }
2589
2590                     if(i < index){
2591                         av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
2592                         memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
2593                     }else if(i > index){
2594                         Picture tmp= h->ref_list[list][i];
2595                         for(; i>index; i--){
2596                             h->ref_list[list][i]= h->ref_list[list][i-1];
2597                         }
2598                         h->ref_list[list][index]= tmp;
2599                     }
2600                 }else if(reordering_of_pic_nums_idc==3) 
2601                     break;
2602                 else{
2603                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
2604                     return -1;
2605                 }
2606             }
2607         }
2608
2609         if(h->slice_type!=B_TYPE) break;
2610     }
2611     return 0;    
2612 }
2613
2614 static int pred_weight_table(H264Context *h){
2615     MpegEncContext * const s = &h->s;
2616     int list, i;
2617     
2618     h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
2619     h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
2620
2621     for(list=0; list<2; list++){
2622         for(i=0; i<h->ref_count[list]; i++){
2623             int luma_weight_flag, chroma_weight_flag;
2624             
2625             luma_weight_flag= get_bits1(&s->gb);
2626             if(luma_weight_flag){
2627                 h->luma_weight[list][i]= get_se_golomb(&s->gb);
2628                 h->luma_offset[list][i]= get_se_golomb(&s->gb);
2629             }
2630
2631             chroma_weight_flag= get_bits1(&s->gb);
2632             if(chroma_weight_flag){
2633                 int j;
2634                 for(j=0; j<2; j++){
2635                     h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
2636                     h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
2637                 }
2638             }
2639         }
2640         if(h->slice_type != B_TYPE) break;
2641     }
2642     return 0;
2643 }
2644
2645 /**
2646  * instantaneos decoder refresh.
2647  */
2648 static void idr(H264Context *h){
2649     int i;
2650
2651     for(i=0; i<h->long_ref_count; i++){
2652         h->long_ref[i]->reference=0;
2653         h->long_ref[i]= NULL;
2654     }
2655     h->long_ref_count=0;
2656
2657     for(i=0; i<h->short_ref_count; i++){
2658         h->short_ref[i]->reference=0;
2659         h->short_ref[i]= NULL;
2660     }
2661     h->short_ref_count=0;
2662 }
2663
2664 /**
2665  *
2666  * @return the removed picture or NULL if an error occures
2667  */
2668 static Picture * remove_short(H264Context *h, int frame_num){
2669     MpegEncContext * const s = &h->s;
2670     int i;
2671     
2672     if(s->avctx->debug&FF_DEBUG_MMCO)
2673         av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
2674     
2675     for(i=0; i<h->short_ref_count; i++){
2676         Picture *pic= h->short_ref[i];
2677         if(s->avctx->debug&FF_DEBUG_MMCO)
2678             av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
2679         if(pic->frame_num == frame_num){
2680             h->short_ref[i]= NULL;
2681             memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
2682             h->short_ref_count--;
2683             return pic;
2684         }
2685     }
2686     return NULL;
2687 }
2688
2689 /**
2690  *
2691  * @return the removed picture or NULL if an error occures
2692  */
2693 static Picture * remove_long(H264Context *h, int i){
2694     Picture *pic;
2695
2696     if(i >= h->long_ref_count) return NULL;
2697     pic= h->long_ref[i];
2698     if(pic==NULL) return NULL;
2699     
2700     h->long_ref[i]= NULL;
2701     memmove(&h->long_ref[i], &h->long_ref[i+1], (h->long_ref_count - i - 1)*sizeof(Picture*));
2702     h->long_ref_count--;
2703
2704     return pic;
2705 }
2706
2707 /**
2708  * Executes the reference picture marking (memory management control operations).
2709  */
2710 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
2711     MpegEncContext * const s = &h->s;
2712     int i;
2713     int current_is_long=0;
2714     Picture *pic;
2715     
2716     if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
2717         av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
2718         
2719     for(i=0; i<mmco_count; i++){
2720         if(s->avctx->debug&FF_DEBUG_MMCO)
2721             av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);
2722
2723         switch(mmco[i].opcode){
2724         case MMCO_SHORT2UNUSED:
2725             pic= remove_short(h, mmco[i].short_frame_num);
2726             if(pic==NULL) return -1;
2727             pic->reference= 0;
2728             break;
2729         case MMCO_SHORT2LONG:
2730             pic= remove_long(h, mmco[i].long_index);
2731             if(pic) pic->reference=0;
2732             
2733             h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);
2734             h->long_ref[ mmco[i].long_index ]->long_ref=1;
2735             break;
2736         case MMCO_LONG2UNUSED:
2737             pic= remove_long(h, mmco[i].long_index);
2738             if(pic==NULL) return -1;
2739             pic->reference= 0;
2740             break;
2741         case MMCO_LONG:
2742             pic= remove_long(h, mmco[i].long_index);
2743             if(pic) pic->reference=0;
2744             
2745             h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;
2746             h->long_ref[ mmco[i].long_index ]->long_ref=1;
2747             h->long_ref_count++;
2748             
2749             current_is_long=1;
2750             break;
2751         case MMCO_SET_MAX_LONG:
2752             assert(mmco[i].long_index <= 16);
2753             while(mmco[i].long_index < h->long_ref_count){
2754                 pic= remove_long(h, mmco[i].long_index);
2755                 pic->reference=0;
2756             }
2757             while(mmco[i].long_index > h->long_ref_count){
2758                 h->long_ref[ h->long_ref_count++ ]= NULL;
2759             }
2760             break;
2761         case MMCO_RESET:
2762             while(h->short_ref_count){
2763                 pic= remove_short(h, h->short_ref[0]->frame_num);
2764                 pic->reference=0;
2765             }
2766             while(h->long_ref_count){
2767                 pic= remove_long(h, h->long_ref_count-1);
2768                 pic->reference=0;
2769             }
2770             break;
2771         default: assert(0);
2772         }
2773     }
2774     
2775     if(!current_is_long){
2776         pic= remove_short(h, s->current_picture_ptr->frame_num);
2777         if(pic){
2778             pic->reference=0;
2779             av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
2780         }
2781         
2782         if(h->short_ref_count)
2783             memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
2784
2785         h->short_ref[0]= s->current_picture_ptr;
2786         h->short_ref[0]->long_ref=0;
2787         h->short_ref_count++;
2788     }
2789     
2790     return 0; 
2791 }
2792
2793 static int decode_ref_pic_marking(H264Context *h){
2794     MpegEncContext * const s = &h->s;
2795     int i;
2796     
2797     if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
2798         s->broken_link= get_bits1(&s->gb) -1;
2799         h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx
2800         if(h->mmco[0].long_index == -1)
2801             h->mmco_index= 0;
2802         else{
2803             h->mmco[0].opcode= MMCO_LONG;
2804             h->mmco_index= 1;
2805         } 
2806     }else{
2807         if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag
2808             for(i= h->mmco_index; i<MAX_MMCO_COUNT; i++) { 
2809                 MMCOOpcode opcode= get_ue_golomb(&s->gb);;
2810
2811                 h->mmco[i].opcode= opcode;
2812                 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
2813                     h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields
2814 /*                    if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){
2815                         fprintf(stderr, "illegal short ref in memory management control operation %d\n", mmco);
2816                         return -1;
2817                     }*/
2818                 }
2819                 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
2820                     h->mmco[i].long_index= get_ue_golomb(&s->gb);
2821                     if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){
2822                         av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
2823                         return -1;
2824                     }
2825                 }
2826                     
2827                 if(opcode > MMCO_LONG){
2828                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
2829                     return -1;
2830                 }
2831             }
2832             h->mmco_index= i;
2833         }else{
2834             assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
2835
2836             if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields
2837                 h->mmco[0].opcode= MMCO_SHORT2UNUSED;
2838                 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
2839                 h->mmco_index= 1;
2840             }else
2841                 h->mmco_index= 0;
2842         }
2843     }
2844     
2845     return 0; 
2846 }
2847
2848 static int init_poc(H264Context *h){
2849     MpegEncContext * const s = &h->s;
2850     const int max_frame_num= 1<<h->sps.log2_max_frame_num;
2851     int field_poc[2];
2852
2853     if(h->nal_unit_type == NAL_IDR_SLICE){
2854         h->frame_num_offset= 0;
2855     }else{
2856         if(h->frame_num < h->prev_frame_num)
2857             h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;
2858         else
2859             h->frame_num_offset= h->prev_frame_num_offset;
2860     }
2861
2862     if(h->sps.poc_type==0){
2863         const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
2864
2865         if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
2866             h->poc_msb = h->prev_poc_msb + max_poc_lsb;
2867         else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
2868             h->poc_msb = h->prev_poc_msb - max_poc_lsb;
2869         else
2870             h->poc_msb = h->prev_poc_msb;
2871 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
2872         field_poc[0] = 
2873         field_poc[1] = h->poc_msb + h->poc_lsb;
2874         if(s->picture_structure == PICT_FRAME) 
2875             field_poc[1] += h->delta_poc_bottom;
2876     }else if(h->sps.poc_type==1){
2877         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
2878         int i;
2879
2880         if(h->sps.poc_cycle_length != 0)
2881             abs_frame_num = h->frame_num_offset + h->frame_num;
2882         else
2883             abs_frame_num = 0;
2884
2885         if(h->nal_ref_idc==0 && abs_frame_num > 0)
2886             abs_frame_num--;
2887             
2888         expected_delta_per_poc_cycle = 0;
2889         for(i=0; i < h->sps.poc_cycle_length; i++)
2890             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
2891
2892         if(abs_frame_num > 0){
2893             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
2894             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
2895
2896             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
2897             for(i = 0; i <= frame_num_in_poc_cycle; i++)
2898                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
2899         } else
2900             expectedpoc = 0;
2901
2902         if(h->nal_ref_idc == 0) 
2903             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
2904         
2905         field_poc[0] = expectedpoc + h->delta_poc[0];
2906         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
2907
2908         if(s->picture_structure == PICT_FRAME)
2909             field_poc[1] += h->delta_poc[1];
2910     }else{
2911         int poc;
2912         if(h->nal_unit_type == NAL_IDR_SLICE){
2913             poc= 0;
2914         }else{
2915             if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);
2916             else               poc= 2*(h->frame_num_offset + h->frame_num) - 1;
2917         }
2918         field_poc[0]= poc;
2919         field_poc[1]= poc;
2920     }
2921     
2922     if(s->picture_structure != PICT_BOTTOM_FIELD)
2923         s->current_picture_ptr->field_poc[0]= field_poc[0];
2924     if(s->picture_structure != PICT_TOP_FIELD)
2925         s->current_picture_ptr->field_poc[1]= field_poc[1];
2926     if(s->picture_structure == PICT_FRAME) // FIXME field pix?
2927         s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);
2928
2929     return 0;
2930 }
2931
2932 /**
2933  * decodes a slice header.
2934  * this will allso call MPV_common_init() and frame_start() as needed
2935  */
2936 static int decode_slice_header(H264Context *h){
2937     MpegEncContext * const s = &h->s;
2938     int first_mb_in_slice, pps_id;
2939     int num_ref_idx_active_override_flag;
2940     static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};
2941
2942     s->current_picture.reference= h->nal_ref_idc != 0;
2943
2944     first_mb_in_slice= get_ue_golomb(&s->gb);
2945
2946     h->slice_type= get_ue_golomb(&s->gb);
2947     if(h->slice_type > 9){
2948         av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
2949     }
2950     if(h->slice_type > 4){
2951         h->slice_type -= 5;
2952         h->slice_type_fixed=1;
2953     }else
2954         h->slice_type_fixed=0;
2955     
2956     h->slice_type= slice_type_map[ h->slice_type ];
2957     
2958     s->pict_type= h->slice_type; // to make a few old func happy, its wrong though
2959         
2960     pps_id= get_ue_golomb(&s->gb);
2961     if(pps_id>255){
2962         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
2963         return -1;
2964     }
2965     h->pps= h->pps_buffer[pps_id];
2966     if(h->pps.slice_group_count == 0){
2967         av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
2968         return -1;
2969     }
2970
2971     h->sps= h->sps_buffer[ h->pps.sps_id ];
2972     if(h->sps.log2_max_frame_num == 0){
2973         av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
2974         return -1;
2975     }
2976     
2977     s->mb_width= h->sps.mb_width;
2978     s->mb_height= h->sps.mb_height;
2979     
2980     h->b_stride=  s->mb_width*4;
2981     h->b8_stride= s->mb_width*2;
2982
2983     s->mb_x = first_mb_in_slice % s->mb_width;
2984     s->mb_y = first_mb_in_slice / s->mb_width; //FIXME AFFW
2985     
2986     s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );
2987     if(h->sps.frame_mbs_only_flag)
2988         s->height= 16*s->mb_height - 2*(h->sps.crop_top  + h->sps.crop_bottom);
2989     else
2990         s->height= 16*s->mb_height - 4*(h->sps.crop_top  + h->sps.crop_bottom); //FIXME recheck
2991     
2992     if (s->context_initialized 
2993         && (   s->width != s->avctx->width || s->height != s->avctx->height)) {
2994         free_tables(h);
2995         MPV_common_end(s);
2996     }
2997     if (!s->context_initialized) {
2998         if (MPV_common_init(s) < 0)
2999             return -1;
3000
3001         alloc_tables(h);
3002
3003         s->avctx->width = s->width;
3004         s->avctx->height = s->height;
3005         s->avctx->sample_aspect_ratio= h->sps.sar;
3006     }
3007
3008     if(first_mb_in_slice == 0){
3009         frame_start(h);
3010     }
3011
3012     s->current_picture_ptr->frame_num= //FIXME frame_num cleanup
3013     h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
3014
3015     if(h->sps.frame_mbs_only_flag){
3016         s->picture_structure= PICT_FRAME;
3017     }else{
3018         if(get_bits1(&s->gb)) //field_pic_flag
3019             s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
3020         else
3021             s->picture_structure= PICT_FRAME;
3022     }
3023
3024     if(s->picture_structure==PICT_FRAME){
3025         h->curr_pic_num=   h->frame_num;
3026         h->max_pic_num= 1<< h->sps.log2_max_frame_num;
3027     }else{
3028         h->curr_pic_num= 2*h->frame_num;
3029         h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
3030     }
3031         
3032     if(h->nal_unit_type == NAL_IDR_SLICE){
3033         get_ue_golomb(&s->gb); /* idr_pic_id */
3034     }
3035    
3036     if(h->sps.poc_type==0){
3037         h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
3038         
3039         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
3040             h->delta_poc_bottom= get_se_golomb(&s->gb);
3041         }
3042     }
3043     
3044     if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
3045         h->delta_poc[0]= get_se_golomb(&s->gb);
3046         
3047         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
3048             h->delta_poc[1]= get_se_golomb(&s->gb);
3049     }
3050     
3051     init_poc(h);
3052     
3053     if(h->pps.redundant_pic_cnt_present){
3054         h->redundant_pic_count= get_ue_golomb(&s->gb);
3055     }
3056
3057     //set defaults, might be overriden a few line later
3058     h->ref_count[0]= h->pps.ref_count[0];
3059     h->ref_count[1]= h->pps.ref_count[1];
3060
3061     if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){
3062         if(h->slice_type == B_TYPE){
3063             h->direct_spatial_mv_pred= get_bits1(&s->gb);
3064         }
3065         num_ref_idx_active_override_flag= get_bits1(&s->gb);
3066     
3067         if(num_ref_idx_active_override_flag){
3068             h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
3069             if(h->slice_type==B_TYPE)
3070                 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
3071
3072             if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
3073                 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
3074                 return -1;
3075             }
3076         }
3077     }
3078
3079     if(first_mb_in_slice == 0){
3080         fill_default_ref_list(h);
3081     }
3082
3083     decode_ref_pic_list_reordering(h);
3084
3085     if(   (h->pps.weighted_pred          && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) 
3086        || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )
3087         pred_weight_table(h);
3088     
3089     if(s->current_picture.reference)
3090         decode_ref_pic_marking(h);
3091
3092     if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )
3093         h->cabac_init_idc = get_ue_golomb(&s->gb);
3094
3095     h->last_qscale_diff = 0;
3096     s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);
3097     if(s->qscale<0 || s->qscale>51){
3098         av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);
3099         return -1;
3100     }
3101     //FIXME qscale / qp ... stuff
3102     if(h->slice_type == SP_TYPE){
3103         get_bits1(&s->gb); /* sp_for_switch_flag */
3104     }
3105     if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){
3106         get_se_golomb(&s->gb); /* slice_qs_delta */
3107     }
3108
3109     h->deblocking_filter = 1;
3110     h->slice_alpha_c0_offset = 0;
3111     h->slice_beta_offset = 0;
3112     if( h->pps.deblocking_filter_parameters_present ) {
3113         h->deblocking_filter= get_ue_golomb(&s->gb);
3114         if(h->deblocking_filter < 2) 
3115             h->deblocking_filter^= 1; // 1<->0
3116
3117         if( h->deblocking_filter ) {
3118             h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
3119             h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
3120         }
3121     }
3122
3123 #if 0 //FMO
3124     if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
3125         slice_group_change_cycle= get_bits(&s->gb, ?);
3126 #endif
3127
3128     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
3129         av_log(h->s.avctx, AV_LOG_DEBUG, "mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d\n", 
3130                first_mb_in_slice, 
3131                av_get_pict_type_char(h->slice_type),
3132                pps_id, h->frame_num,
3133                s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
3134                h->ref_count[0], h->ref_count[1],
3135                s->qscale,
3136                h->deblocking_filter
3137                );
3138     }
3139
3140     return 0;
3141 }
3142
3143 /**
3144  *
3145  */
3146 static inline int get_level_prefix(GetBitContext *gb){
3147     unsigned int buf;
3148     int log;
3149     
3150     OPEN_READER(re, gb);
3151     UPDATE_CACHE(re, gb);
3152     buf=GET_CACHE(re, gb);
3153     
3154     log= 32 - av_log2(buf);
3155 #ifdef TRACE
3156     print_bin(buf>>(32-log), log);
3157     printf("%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
3158 #endif
3159
3160     LAST_SKIP_BITS(re, gb, log);
3161     CLOSE_READER(re, gb);
3162
3163     return log-1;
3164 }
3165
3166 /**
3167  * decodes a residual block.
3168  * @param n block index
3169  * @param scantable scantable
3170  * @param max_coeff number of coefficients in the block
3171  * @return <0 if an error occured
3172  */
3173 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, int qp, int max_coeff){
3174     MpegEncContext * const s = &h->s;
3175     const uint16_t *qmul= dequant_coeff[qp];
3176     static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
3177     int level[16], run[16];
3178     int suffix_length, zeros_left, coeff_num, coeff_token, total_coeff, i, trailing_ones;
3179
3180     //FIXME put trailing_onex into the context
3181
3182     if(n == CHROMA_DC_BLOCK_INDEX){
3183         coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
3184         total_coeff= coeff_token>>2;
3185     }else{    
3186         if(n == LUMA_DC_BLOCK_INDEX){
3187             total_coeff= pred_non_zero_count(h, 0);
3188             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
3189             total_coeff= coeff_token>>2;
3190         }else{
3191             total_coeff= pred_non_zero_count(h, n);
3192             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
3193             total_coeff= coeff_token>>2;
3194             h->non_zero_count_cache[ scan8[n] ]= total_coeff;
3195         }
3196     }
3197
3198     //FIXME set last_non_zero?
3199
3200     if(total_coeff==0)
3201         return 0;
3202         
3203     trailing_ones= coeff_token&3;
3204     tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);
3205     assert(total_coeff<=16);
3206     
3207     for(i=0; i<trailing_ones; i++){
3208         level[i]= 1 - 2*get_bits1(gb);
3209     }
3210
3211     suffix_length= total_coeff > 10 && trailing_ones < 3;
3212
3213     for(; i<total_coeff; i++){
3214         const int prefix= get_level_prefix(gb);
3215         int level_code, mask;
3216
3217         if(prefix<14){ //FIXME try to build a large unified VLC table for all this
3218             if(suffix_length)
3219                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
3220             else
3221                 level_code= (prefix<<suffix_length); //part
3222         }else if(prefix==14){
3223             if(suffix_length)
3224                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
3225             else
3226                 level_code= prefix + get_bits(gb, 4); //part
3227         }else if(prefix==15){
3228             level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
3229             if(suffix_length==0) level_code+=15; //FIXME doesnt make (much)sense
3230         }else{
3231             av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
3232             return -1;
3233         }
3234
3235         if(i==trailing_ones && i<3) level_code+= 2; //FIXME split first iteration
3236
3237         mask= -(level_code&1);
3238         level[i]= (((2+level_code)>>1) ^ mask) - mask;
3239
3240         if(suffix_length==0) suffix_length=1; //FIXME split first iteration
3241
3242 #if 1
3243         if(ABS(level[i]) > (3<<(suffix_length-1)) && suffix_length<6) suffix_length++;
3244 #else        
3245         if((2+level_code)>>1) > (3<<(suffix_length-1)) && suffix_length<6) suffix_length++;
3246         /* ? == prefix > 2 or sth */
3247 #endif
3248         tprintf("level: %d suffix_length:%d\n", level[i], suffix_length);
3249     }
3250
3251     if(total_coeff == max_coeff)
3252         zeros_left=0;
3253     else{
3254         if(n == CHROMA_DC_BLOCK_INDEX)
3255             zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
3256         else
3257             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
3258     }
3259     
3260     for(i=0; i<total_coeff-1; i++){
3261         if(zeros_left <=0)
3262             break;
3263         else if(zeros_left < 7){
3264             run[i]= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
3265         }else{
3266             run[i]= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
3267         }
3268         zeros_left -= run[i];
3269     }
3270
3271     if(zeros_left<0){
3272         av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
3273         return -1;
3274     }
3275     
3276     for(; i<total_coeff-1; i++){
3277         run[i]= 0;
3278     }
3279
3280     run[i]= zeros_left;
3281
3282     coeff_num=-1;
3283     if(n > 24){
3284         for(i=total_coeff-1; i>=0; i--){ //FIXME merge into rundecode?
3285             int j;
3286
3287             coeff_num += run[i] + 1; //FIXME add 1 earlier ?
3288             j= scantable[ coeff_num ];
3289
3290             block[j]= level[i];
3291         }
3292     }else{
3293         for(i=total_coeff-1; i>=0; i--){ //FIXME merge into  rundecode?
3294             int j;
3295
3296             coeff_num += run[i] + 1; //FIXME add 1 earlier ?
3297             j= scantable[ coeff_num ];
3298
3299             block[j]= level[i] * qmul[j];
3300 //            printf("%d %d  ", block[j], qmul[j]);
3301         }
3302     }
3303     return 0;
3304 }
3305
3306 /**
3307  * decodes a macroblock
3308  * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
3309  */
3310 static int decode_mb_cavlc(H264Context *h){
3311     MpegEncContext * const s = &h->s;
3312     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
3313     int mb_type, partition_count, cbp;
3314
3315     s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong?    
3316
3317     tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
3318     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
3319                 down the code */
3320     if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
3321         if(s->mb_skip_run==-1)
3322             s->mb_skip_run= get_ue_golomb(&s->gb);
3323         
3324         if (s->mb_skip_run--) {
3325             int mx, my;
3326             /* skip mb */
3327 //FIXME b frame
3328             mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0;
3329
3330             memset(h->non_zero_count[mb_xy], 0, 16);
3331             memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
3332
3333             if(h->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){
3334                 h->mb_field_decoding_flag= get_bits1(&s->gb);
3335             }
3336
3337             if(h->mb_field_decoding_flag)
3338                 mb_type|= MB_TYPE_INTERLACED;
3339             
3340             fill_caches(h, mb_type); //FIXME check what is needed and what not ...
3341             pred_pskip_motion(h, &mx, &my);
3342             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
3343             fill_rectangle(  h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
3344             write_back_motion(h, mb_type);
3345
3346             s->current_picture.mb_type[mb_xy]= mb_type; //FIXME SKIP type
3347             s->current_picture.qscale_table[mb_xy]= s->qscale;
3348             h->slice_table[ mb_xy ]= h->slice_num;
3349
3350             h->prev_mb_skiped= 1;
3351             return 0;
3352         }
3353     }
3354     if(h->sps.mb_aff /* && !field pic FIXME needed? */){
3355         if((s->mb_y&1)==0)
3356             h->mb_field_decoding_flag = get_bits1(&s->gb);
3357     }else
3358         h->mb_field_decoding_flag=0; //FIXME som ed note ?!
3359     
3360     h->prev_mb_skiped= 0;
3361     
3362     mb_type= get_ue_golomb(&s->gb);
3363     if(h->slice_type == B_TYPE){
3364         if(mb_type < 23){
3365             partition_count= b_mb_type_info[mb_type].partition_count;
3366             mb_type=         b_mb_type_info[mb_type].type;
3367         }else{
3368             mb_type -= 23;
3369             goto decode_intra_mb;
3370         }
3371     }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
3372         if(mb_type < 5){
3373             partition_count= p_mb_type_info[mb_type].partition_count;
3374             mb_type=         p_mb_type_info[mb_type].type;
3375         }else{
3376             mb_type -= 5;
3377             goto decode_intra_mb;
3378         }
3379     }else{
3380        assert(h->slice_type == I_TYPE);
3381 decode_intra_mb:
3382         if(mb_type > 25){
3383             av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
3384             return -1;
3385         }
3386         partition_count=0;
3387         cbp= i_mb_type_info[mb_type].cbp;
3388         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
3389         mb_type= i_mb_type_info[mb_type].type;
3390     }
3391
3392     if(h->mb_field_decoding_flag)
3393         mb_type |= MB_TYPE_INTERLACED;
3394
3395     s->current_picture.mb_type[mb_xy]= mb_type;
3396     h->slice_table[ mb_xy ]= h->slice_num;
3397     
3398     if(IS_INTRA_PCM(mb_type)){
3399         const uint8_t *ptr;
3400         int x, y;
3401         
3402         // we assume these blocks are very rare so we dont optimize it
3403         align_get_bits(&s->gb);
3404         
3405         ptr= s->gb.buffer + get_bits_count(&s->gb);
3406     
3407         for(y=0; y<16; y++){
3408             const int index= 4*(y&3) + 64*(y>>2);
3409             for(x=0; x<16; x++){
3410                 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
3411             }
3412         }
3413         for(y=0; y<8; y++){
3414             const int index= 256 + 4*(y&3) + 32*(y>>2);
3415             for(x=0; x<8; x++){
3416                 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
3417             }
3418         }
3419         for(y=0; y<8; y++){
3420             const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
3421             for(x=0; x<8; x++){
3422                 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
3423             }
3424         }
3425     
3426         skip_bits(&s->gb, 384); //FIXME check /fix the bitstream readers
3427         
3428         //FIXME deblock filter, non_zero_count_cache init ...
3429         memset(h->non_zero_count[mb_xy], 16, 16);
3430         s->current_picture.qscale_table[mb_xy]= s->qscale;
3431         
3432         return 0;
3433     }
3434         
3435     fill_caches(h, mb_type);
3436
3437     //mb_pred
3438     if(IS_INTRA(mb_type)){
3439 //            init_top_left_availability(h);
3440             if(IS_INTRA4x4(mb_type)){
3441                 int i;
3442
3443 //                fill_intra4x4_pred_table(h);
3444                 for(i=0; i<16; i++){
3445                     const int mode_coded= !get_bits1(&s->gb);
3446                     const int predicted_mode=  pred_intra_mode(h, i);
3447                     int mode;
3448
3449                     if(mode_coded){
3450                         const int rem_mode= get_bits(&s->gb, 3);
3451                         if(rem_mode<predicted_mode)
3452                             mode= rem_mode;
3453                         else
3454                             mode= rem_mode + 1;
3455                     }else{
3456                         mode= predicted_mode;
3457                     }
3458                     
3459                     h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
3460                 }
3461                 write_back_intra_pred_mode(h);
3462                 if( check_intra4x4_pred_mode(h) < 0)
3463                     return -1;
3464             }else{
3465                 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
3466                 if(h->intra16x16_pred_mode < 0)
3467                     return -1;
3468             }
3469             h->chroma_pred_mode= get_ue_golomb(&s->gb);
3470
3471             h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
3472             if(h->chroma_pred_mode < 0)
3473                 return -1;
3474     }else if(partition_count==4){
3475         int i, j, sub_partition_count[4], list, ref[2][4];
3476         
3477         if(h->slice_type == B_TYPE){
3478             for(i=0; i<4; i++){
3479                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
3480                 if(h->sub_mb_type[i] >=13){
3481                     av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
3482                     return -1;
3483                 }
3484                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
3485                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
3486             }
3487         }else{
3488             assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
3489             for(i=0; i<4; i++){
3490                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
3491                 if(h->sub_mb_type[i] >=4){
3492                     av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
3493                     return -1;
3494                 }
3495                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
3496                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
3497             }
3498         }
3499         
3500         for(list=0; list<2; list++){
3501             const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
3502             if(ref_count == 0) continue;
3503             for(i=0; i<4; i++){
3504                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
3505                     ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
3506                 }else{
3507                  //FIXME
3508                     ref[list][i] = -1;
3509                 }
3510             }
3511         }
3512         
3513         for(list=0; list<2; list++){
3514             const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
3515             if(ref_count == 0) continue;
3516
3517             for(i=0; i<4; i++){
3518                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
3519                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
3520
3521                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
3522                     const int sub_mb_type= h->sub_mb_type[i];
3523                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
3524                     for(j=0; j<sub_partition_count[i]; j++){
3525                         int mx, my;
3526                         const int index= 4*i + block_width*j;
3527                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
3528                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
3529                         mx += get_se_golomb(&s->gb);
3530                         my += get_se_golomb(&s->gb);
3531                         tprintf("final mv:%d %d\n", mx, my);
3532
3533                         if(IS_SUB_8X8(sub_mb_type)){
3534                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= 
3535                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
3536                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= 
3537                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
3538                         }else if(IS_SUB_8X4(sub_mb_type)){
3539                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
3540                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
3541                         }else if(IS_SUB_4X8(sub_mb_type)){
3542                             mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
3543                             mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
3544                         }else{
3545                             assert(IS_SUB_4X4(sub_mb_type));
3546                             mv_cache[ 0 ][0]= mx;
3547                             mv_cache[ 0 ][1]= my;
3548                         }
3549                     }
3550                 }else{
3551                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
3552                     p[0] = p[1]=
3553                     p[8] = p[9]= 0;
3554                 }
3555             }
3556         }
3557     }else if(!IS_DIRECT(mb_type)){
3558         int list, mx, my, i;
3559          //FIXME we should set ref_idx_l? to 0 if we use that later ...
3560         if(IS_16X16(mb_type)){
3561             for(list=0; list<2; list++){
3562                 if(h->ref_count[0]>0){
3563                     if(IS_DIR(mb_type, 0, list)){
3564                         const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
3565                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
3566                     }
3567                 }
3568             }
3569             for(list=0; list<2; list++){
3570                 if(IS_DIR(mb_type, 0, list)){
3571                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
3572                     mx += get_se_golomb(&s->gb);
3573                     my += get_se_golomb(&s->gb);
3574                     tprintf("final mv:%d %d\n", mx, my);
3575
3576                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
3577                 }
3578             }
3579         }
3580         else if(IS_16X8(mb_type)){
3581             for(list=0; list<2; list++){
3582                 if(h->ref_count[list]>0){
3583                     for(i=0; i<2; i++){
3584                         if(IS_DIR(mb_type, i, list)){
3585                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
3586                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
3587                         }
3588                     }
3589                 }
3590             }
3591             for(list=0; list<2; list++){
3592                 for(i=0; i<2; i++){
3593                     if(IS_DIR(mb_type, i, list)){
3594                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
3595                         mx += get_se_golomb(&s->gb);
3596                         my += get_se_golomb(&s->gb);
3597                         tprintf("final mv:%d %d\n", mx, my);
3598
3599                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
3600                     }
3601                 }
3602             }
3603         }else{
3604             assert(IS_8X16(mb_type));
3605             for(list=0; list<2; list++){
3606                 if(h->ref_count[list]>0){
3607                     for(i=0; i<2; i++){
3608                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
3609                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
3610                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
3611                         }
3612                     }
3613                 }
3614             }
3615             for(list=0; list<2; list++){
3616                 for(i=0; i<2; i++){
3617                     if(IS_DIR(mb_type, i, list)){
3618                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
3619                         mx += get_se_golomb(&s->gb);
3620                         my += get_se_golomb(&s->gb);
3621                         tprintf("final mv:%d %d\n", mx, my);
3622
3623                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
3624                     }
3625                 }
3626             }
3627         }
3628     }
3629     
3630     if(IS_INTER(mb_type))
3631         write_back_motion(h, mb_type);
3632     
3633     if(!IS_INTRA16x16(mb_type)){
3634         cbp= get_ue_golomb(&s->gb);
3635         if(cbp > 47){
3636             av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
3637             return -1;