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