2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
25 * H.264 / AVC / MPEG4 part10 codec.
26 * @author Michael Niedermayer <michaelni@gmx.at>
32 #include "mpegvideo.h"
41 #define interlaced_dct interlaced_dct_is_a_bad_name
42 #define mb_intra mb_intra_isnt_initalized_see_mb_type
44 #define LUMA_DC_BLOCK_INDEX 25
45 #define CHROMA_DC_BLOCK_INDEX 26
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
54 #define MAX_SPS_COUNT 32
55 #define MAX_PPS_COUNT 256
57 #define MAX_MMCO_COUNT 66
59 /* Compiling in interlaced support reduces the speed
60 * of progressive decoding by about 2%. */
61 #define ALLOW_INTERLACE
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
72 #define IS_INTERLACED(mb_type) 0
76 * Sequence parameter set
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;
104 int timing_info_present_flag;
105 uint32_t num_units_in_tick;
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];
117 * Picture parameter set
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 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];
140 * Memory management control operation opcode.
142 typedef enum MMCOOpcode{
153 * Memory management control operation.
164 typedef struct H264Context{
168 uint8_t *rbsp_buffer;
169 unsigned int rbsp_buffer_size;
172 * Used to parse AVC variant of h264
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)
184 int chroma_pred_mode;
185 int intra16x16_pred_mode;
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)];
204 * non zero coeff count cache.
205 * is 64 if not available.
207 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);
208 uint8_t (*non_zero_count)[16];
211 * Motion vector cache.
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
219 * is 1 if the specific list MV&references are set to 0,0,-2.
221 int mv_cache_clean[2];
224 * number of neighbors (top and/or left) that used 8x8 dct
226 int neighbor_transform_size;
229 * block_offset[ 0..23] for frame macroblocks
230 * block_offset[24..47] for field macroblocks
232 int block_offset[2*(16+8)];
234 uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
236 int b_stride; //FIXME use s->b4_stride
239 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff
248 int unknown_svq3_flag;
249 int next_slice_index;
251 SPS sps_buffer[MAX_SPS_COUNT];
252 SPS sps; ///< current sps
254 PPS pps_buffer[MAX_PPS_COUNT];
258 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
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
267 uint8_t *slice_table_base;
268 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1
270 int slice_type_fixed;
272 //interlacing specific flags
274 int mb_field_decoding_flag;
275 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag
282 int delta_poc_bottom;
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
292 * frame_num for frames or 2*frame_num for field pics.
297 * max_frame_num or 2*max_frame_num for field pics.
301 //Weighted pred stuff
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];
313 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0
314 int slice_alpha_c0_offset;
315 int slice_beta_offset;
317 int redundant_pic_count;
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];
326 * num_ref_idx_l0/1_active_minus1 + 1
328 int ref_count[2]; ///< counts frames or fields, depending on current mb mode
329 Picture *short_ref[32];
330 Picture *long_ref[32];
331 Picture default_ref_list[2][32];
332 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs
333 Picture *delayed_pic[16]; //FIXME size?
334 Picture *delayed_output_pic;
337 * memory management control operations buffer.
339 MMCO mmco[MAX_MMCO_COUNT];
342 int long_ref_count; ///< number of actual long term references
343 int short_ref_count; ///< number of actual short term references
346 GetBitContext intra_gb;
347 GetBitContext inter_gb;
348 GetBitContext *intra_gb_ptr;
349 GetBitContext *inter_gb_ptr;
351 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]);
357 uint8_t cabac_state[460];
360 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
365 /* chroma_pred_mode for i4x4 or i16x16, else 0 */
366 uint8_t *chroma_pred_mode_table;
367 int last_qscale_diff;
368 int16_t (*mvd_table[2])[2];
369 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);
370 uint8_t *direct_table;
371 uint8_t direct_cache[5*8];
373 uint8_t zigzag_scan[16];
374 uint8_t zigzag_scan8x8[64];
375 uint8_t zigzag_scan8x8_cavlc[64];
376 uint8_t field_scan[16];
377 uint8_t field_scan8x8[64];
378 uint8_t field_scan8x8_cavlc[64];
379 const uint8_t *zigzag_scan_q0;
380 const uint8_t *zigzag_scan8x8_q0;
381 const uint8_t *zigzag_scan8x8_cavlc_q0;
382 const uint8_t *field_scan_q0;
383 const uint8_t *field_scan8x8_q0;
384 const uint8_t *field_scan8x8_cavlc_q0;
389 static VLC coeff_token_vlc[4];
390 static VLC chroma_dc_coeff_token_vlc;
392 static VLC total_zeros_vlc[15];
393 static VLC chroma_dc_total_zeros_vlc[3];
395 static VLC run_vlc[6];
398 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
399 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
400 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);
401 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);
403 static av_always_inline uint32_t pack16to32(int a, int b){
404 #ifdef WORDS_BIGENDIAN
405 return (b&0xFFFF) + (a<<16);
407 return (a&0xFFFF) + (b<<16);
411 const uint8_t ff_rem6[52]={
412 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 const uint8_t ff_div6[52]={
416 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,
422 * @param h height of the rectangle, should be a constant
423 * @param w width of the rectangle, should be a constant
424 * @param size the size of val (1 or 4), should be a constant
426 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
427 uint8_t *p= (uint8_t*)vp;
428 assert(size==1 || size==4);
434 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);
435 assert((stride&(w-1))==0);
437 const uint16_t v= size==4 ? val : val*0x0101;
438 *(uint16_t*)(p + 0*stride)= v;
440 *(uint16_t*)(p + 1*stride)= v;
442 *(uint16_t*)(p + 2*stride)=
443 *(uint16_t*)(p + 3*stride)= v;
445 const uint32_t v= size==4 ? val : val*0x01010101;
446 *(uint32_t*)(p + 0*stride)= v;
448 *(uint32_t*)(p + 1*stride)= v;
450 *(uint32_t*)(p + 2*stride)=
451 *(uint32_t*)(p + 3*stride)= v;
453 //gcc can't optimize 64bit math on x86_32
454 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64)
455 const uint64_t v= val*0x0100000001ULL;
456 *(uint64_t*)(p + 0*stride)= v;
458 *(uint64_t*)(p + 1*stride)= v;
460 *(uint64_t*)(p + 2*stride)=
461 *(uint64_t*)(p + 3*stride)= v;
463 const uint64_t v= val*0x0100000001ULL;
464 *(uint64_t*)(p + 0+0*stride)=
465 *(uint64_t*)(p + 8+0*stride)=
466 *(uint64_t*)(p + 0+1*stride)=
467 *(uint64_t*)(p + 8+1*stride)= v;
469 *(uint64_t*)(p + 0+2*stride)=
470 *(uint64_t*)(p + 8+2*stride)=
471 *(uint64_t*)(p + 0+3*stride)=
472 *(uint64_t*)(p + 8+3*stride)= v;
474 *(uint32_t*)(p + 0+0*stride)=
475 *(uint32_t*)(p + 4+0*stride)= val;
477 *(uint32_t*)(p + 0+1*stride)=
478 *(uint32_t*)(p + 4+1*stride)= val;
480 *(uint32_t*)(p + 0+2*stride)=
481 *(uint32_t*)(p + 4+2*stride)=
482 *(uint32_t*)(p + 0+3*stride)=
483 *(uint32_t*)(p + 4+3*stride)= val;
485 *(uint32_t*)(p + 0+0*stride)=
486 *(uint32_t*)(p + 4+0*stride)=
487 *(uint32_t*)(p + 8+0*stride)=
488 *(uint32_t*)(p +12+0*stride)=
489 *(uint32_t*)(p + 0+1*stride)=
490 *(uint32_t*)(p + 4+1*stride)=
491 *(uint32_t*)(p + 8+1*stride)=
492 *(uint32_t*)(p +12+1*stride)= val;
494 *(uint32_t*)(p + 0+2*stride)=
495 *(uint32_t*)(p + 4+2*stride)=
496 *(uint32_t*)(p + 8+2*stride)=
497 *(uint32_t*)(p +12+2*stride)=
498 *(uint32_t*)(p + 0+3*stride)=
499 *(uint32_t*)(p + 4+3*stride)=
500 *(uint32_t*)(p + 8+3*stride)=
501 *(uint32_t*)(p +12+3*stride)= val;
508 static void fill_caches(H264Context *h, int mb_type, int for_deblock){
509 MpegEncContext * const s = &h->s;
510 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
511 int topleft_xy, top_xy, topright_xy, left_xy[2];
512 int topleft_type, top_type, topright_type, left_type[2];
516 //FIXME deblocking could skip the intra and nnz parts.
517 if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[mb_xy-s->mb_stride]) && !FRAME_MBAFF)
520 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it
522 top_xy = mb_xy - s->mb_stride;
523 topleft_xy = top_xy - 1;
524 topright_xy= top_xy + 1;
525 left_xy[1] = left_xy[0] = mb_xy-1;
535 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
536 const int top_pair_xy = pair_xy - s->mb_stride;
537 const int topleft_pair_xy = top_pair_xy - 1;
538 const int topright_pair_xy = top_pair_xy + 1;
539 const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
540 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
541 const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
542 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
543 const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
544 const int bottom = (s->mb_y & 1);
545 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);
547 ? !curr_mb_frame_flag // bottom macroblock
548 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
550 top_xy -= s->mb_stride;
553 ? !curr_mb_frame_flag // bottom macroblock
554 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
556 topleft_xy -= s->mb_stride;
559 ? !curr_mb_frame_flag // bottom macroblock
560 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
562 topright_xy -= s->mb_stride;
564 if (left_mb_frame_flag != curr_mb_frame_flag) {
565 left_xy[1] = left_xy[0] = pair_xy - 1;
566 if (curr_mb_frame_flag) {
587 left_xy[1] += s->mb_stride;
600 h->top_mb_xy = top_xy;
601 h->left_mb_xy[0] = left_xy[0];
602 h->left_mb_xy[1] = left_xy[1];
606 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0;
607 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0;
608 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0;
610 if(FRAME_MBAFF && !IS_INTRA(mb_type)){
612 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14];
614 h->non_zero_count_cache[scan8[i]] = (v>>i)&1;
615 for(list=0; list<1+(h->slice_type==B_TYPE); list++){
616 if(USES_LIST(mb_type,list)){
617 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]];
618 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]];
619 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
620 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){
626 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
627 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101;
629 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
630 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101;
632 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4);
633 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
638 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
639 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
640 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
641 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
642 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
645 if(IS_INTRA(mb_type)){
646 h->topleft_samples_available=
647 h->top_samples_available=
648 h->left_samples_available= 0xFFFF;
649 h->topright_samples_available= 0xEEEA;
651 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){
652 h->topleft_samples_available= 0xB3FF;
653 h->top_samples_available= 0x33FF;
654 h->topright_samples_available= 0x26EA;
657 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){
658 h->topleft_samples_available&= 0xDF5F;
659 h->left_samples_available&= 0x5F5F;
663 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))
664 h->topleft_samples_available&= 0x7FFF;
666 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))
667 h->topright_samples_available&= 0xFBFF;
669 if(IS_INTRA4x4(mb_type)){
670 if(IS_INTRA4x4(top_type)){
671 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
672 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
673 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
674 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
677 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred))
682 h->intra4x4_pred_mode_cache[4+8*0]=
683 h->intra4x4_pred_mode_cache[5+8*0]=
684 h->intra4x4_pred_mode_cache[6+8*0]=
685 h->intra4x4_pred_mode_cache[7+8*0]= pred;
688 if(IS_INTRA4x4(left_type[i])){
689 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
690 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
693 if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred))
698 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
699 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
714 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)
716 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
717 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
718 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
719 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
721 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
722 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
724 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
725 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
728 h->non_zero_count_cache[4+8*0]=
729 h->non_zero_count_cache[5+8*0]=
730 h->non_zero_count_cache[6+8*0]=
731 h->non_zero_count_cache[7+8*0]=
733 h->non_zero_count_cache[1+8*0]=
734 h->non_zero_count_cache[2+8*0]=
736 h->non_zero_count_cache[1+8*3]=
737 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
741 for (i=0; i<2; i++) {
743 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
744 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
745 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
746 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
748 h->non_zero_count_cache[3+8*1 + 2*8*i]=
749 h->non_zero_count_cache[3+8*2 + 2*8*i]=
750 h->non_zero_count_cache[0+8*1 + 8*i]=
751 h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
758 h->top_cbp = h->cbp_table[top_xy];
759 } else if(IS_INTRA(mb_type)) {
766 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
767 } else if(IS_INTRA(mb_type)) {
773 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
776 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
781 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
783 for(list=0; list<1+(h->slice_type==B_TYPE); list++){
784 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
785 /*if(!h->mv_cache_clean[list]){
786 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
787 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
788 h->mv_cache_clean[list]= 1;
792 h->mv_cache_clean[list]= 0;
794 if(USES_LIST(top_type, list)){
795 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
796 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
797 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
798 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
801 h->ref_cache[list][scan8[0] + 0 - 1*8]=
802 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
803 h->ref_cache[list][scan8[0] + 2 - 1*8]=
804 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
806 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
807 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
808 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
809 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
810 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
813 //FIXME unify cleanup or sth
814 if(USES_LIST(left_type[0], list)){
815 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
816 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
817 *(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]];
818 *(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]];
819 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];
820 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1]>>1)];
822 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=
823 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;
824 h->ref_cache[list][scan8[0] - 1 + 0*8]=
825 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
828 if(USES_LIST(left_type[1], list)){
829 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
830 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;
831 *(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]];
832 *(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]];
833 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];
834 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[3]>>1)];
836 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=
837 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;
838 h->ref_cache[list][scan8[0] - 1 + 2*8]=
839 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
840 assert((!left_type[0]) == (!left_type[1]));
843 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF)
846 if(USES_LIST(topleft_type, list)){
847 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
848 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;
849 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
850 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
852 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
853 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
856 if(USES_LIST(topright_type, list)){
857 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
858 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
859 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
860 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
862 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
863 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
866 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)
869 h->ref_cache[list][scan8[5 ]+1] =
870 h->ref_cache[list][scan8[7 ]+1] =
871 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else)
872 h->ref_cache[list][scan8[4 ]] =
873 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
874 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
875 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
876 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
877 *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
878 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
881 /* XXX beurk, Load mvd */
882 if(USES_LIST(top_type, list)){
883 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
884 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
885 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
886 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
887 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
889 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
890 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
891 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
892 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
894 if(USES_LIST(left_type[0], list)){
895 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
896 *(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]];
897 *(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]];
899 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
900 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
902 if(USES_LIST(left_type[1], list)){
903 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
904 *(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]];
905 *(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]];
907 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
908 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
910 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
911 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
912 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
913 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
914 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
916 if(h->slice_type == B_TYPE){
917 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);
919 if(IS_DIRECT(top_type)){
920 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
921 }else if(IS_8X8(top_type)){
922 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
923 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
924 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
926 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
929 if(IS_DIRECT(left_type[0]))
930 h->direct_cache[scan8[0] - 1 + 0*8]= 1;
931 else if(IS_8X8(left_type[0]))
932 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)];
934 h->direct_cache[scan8[0] - 1 + 0*8]= 0;
936 if(IS_DIRECT(left_type[1]))
937 h->direct_cache[scan8[0] - 1 + 2*8]= 1;
938 else if(IS_8X8(left_type[1]))
939 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)];
941 h->direct_cache[scan8[0] - 1 + 2*8]= 0;
947 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\
948 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\
949 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\
950 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\
951 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\
952 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\
953 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\
954 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\
955 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\
956 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])
958 #define MAP_F2F(idx, mb_type)\
959 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
960 h->ref_cache[list][idx] <<= 1;\
961 h->mv_cache[list][idx][1] /= 2;\
962 h->mvd_cache[list][idx][1] /= 2;\
967 #define MAP_F2F(idx, mb_type)\
968 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
969 h->ref_cache[list][idx] >>= 1;\
970 h->mv_cache[list][idx][1] <<= 1;\
971 h->mvd_cache[list][idx][1] <<= 1;\
981 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
984 static inline void write_back_intra_pred_mode(H264Context *h){
985 MpegEncContext * const s = &h->s;
986 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
988 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
989 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
990 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
991 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
992 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
993 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
994 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
998 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
1000 static inline int check_intra4x4_pred_mode(H264Context *h){
1001 MpegEncContext * const s = &h->s;
1002 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
1003 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
1006 if(!(h->top_samples_available&0x8000)){
1008 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
1010 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 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
1018 if(!(h->left_samples_available&0x8000)){
1020 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
1022 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 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
1031 } //FIXME cleanup like next
1034 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
1036 static inline int check_intra_pred_mode(H264Context *h, int mode){
1037 MpegEncContext * const s = &h->s;
1038 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
1039 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
1041 if(mode < 0 || mode > 6) {
1042 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);
1046 if(!(h->top_samples_available&0x8000)){
1049 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);
1054 if(!(h->left_samples_available&0x8000)){
1057 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);
1066 * gets the predicted intra4x4 prediction mode.
1068 static inline int pred_intra_mode(H264Context *h, int n){
1069 const int index8= scan8[n];
1070 const int left= h->intra4x4_pred_mode_cache[index8 - 1];
1071 const int top = h->intra4x4_pred_mode_cache[index8 - 8];
1072 const int min= FFMIN(left, top);
1074 tprintf("mode:%d %d min:%d\n", left ,top, min);
1076 if(min<0) return DC_PRED;
1080 static inline void write_back_non_zero_count(H264Context *h){
1081 MpegEncContext * const s = &h->s;
1082 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
1084 h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
1085 h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
1086 h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
1087 h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
1088 h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
1089 h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
1090 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
1092 h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
1093 h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
1094 h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
1096 h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
1097 h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
1098 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
1101 // store all luma nnzs, for deblocking
1104 v += (!!h->non_zero_count_cache[scan8[i]]) << i;
1105 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v;
1110 * gets the predicted number of non zero coefficients.
1111 * @param n block index
1113 static inline int pred_non_zero_count(H264Context *h, int n){
1114 const int index8= scan8[n];
1115 const int left= h->non_zero_count_cache[index8 - 1];
1116 const int top = h->non_zero_count_cache[index8 - 8];
1119 if(i<64) i= (i+1)>>1;
1121 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
1126 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
1127 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
1129 /* there is no consistent mapping of mvs to neighboring locations that will
1130 * make mbaff happy, so we can't move all this logic to fill_caches */
1132 MpegEncContext *s = &h->s;
1133 const uint32_t *mb_types = s->current_picture_ptr->mb_type;
1135 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
1136 *C = h->mv_cache[list][scan8[0]-2];
1139 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
1140 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
1141 if(IS_INTERLACED(mb_types[topright_xy])){
1142 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
1143 const int x4 = X4, y4 = Y4;\
1144 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
1145 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\
1146 return LIST_NOT_USED;\
1147 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
1148 h->mv_cache[list][scan8[0]-2][0] = mv[0];\
1149 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
1150 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;
1152 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
1155 if(topright_ref == PART_NOT_AVAILABLE
1156 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
1157 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
1159 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
1160 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
1163 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
1164 && i >= scan8[0]+8){
1165 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok.
1166 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
1172 if(topright_ref != PART_NOT_AVAILABLE){
1173 *C= h->mv_cache[list][ i - 8 + part_width ];
1174 return topright_ref;
1176 tprintf("topright MV not available\n");
1178 *C= h->mv_cache[list][ i - 8 - 1 ];
1179 return h->ref_cache[list][ i - 8 - 1 ];
1184 * gets the predicted MV.
1185 * @param n the block index
1186 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
1187 * @param mx the x component of the predicted motion vector
1188 * @param my the y component of the predicted motion vector
1190 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
1191 const int index8= scan8[n];
1192 const int top_ref= h->ref_cache[list][ index8 - 8 ];
1193 const int left_ref= h->ref_cache[list][ index8 - 1 ];
1194 const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
1195 const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
1197 int diagonal_ref, match_count;
1199 assert(part_width==1 || part_width==2 || part_width==4);
1209 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
1210 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
1211 tprintf("pred_motion match_count=%d\n", match_count);
1212 if(match_count > 1){ //most common
1213 *mx= mid_pred(A[0], B[0], C[0]);
1214 *my= mid_pred(A[1], B[1], C[1]);
1215 }else if(match_count==1){
1219 }else if(top_ref==ref){
1227 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
1231 *mx= mid_pred(A[0], B[0], C[0]);
1232 *my= mid_pred(A[1], B[1], C[1]);
1236 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);
1240 * gets the directionally predicted 16x8 MV.
1241 * @param n the block index
1242 * @param mx the x component of the predicted motion vector
1243 * @param my the y component of the predicted motion vector
1245 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
1247 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ];
1248 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
1250 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);
1258 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ];
1259 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
1261 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);
1263 if(left_ref == ref){
1271 pred_motion(h, n, 4, list, ref, mx, my);
1275 * gets the directionally predicted 8x16 MV.
1276 * @param n the block index
1277 * @param mx the x component of the predicted motion vector
1278 * @param my the y component of the predicted motion vector
1280 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
1282 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ];
1283 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ];
1285 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);
1287 if(left_ref == ref){
1296 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
1298 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);
1300 if(diagonal_ref == ref){
1308 pred_motion(h, n, 2, list, ref, mx, my);
1311 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
1312 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
1313 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
1315 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
1317 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
1318 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
1319 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
1325 pred_motion(h, 0, 4, 0, 0, mx, my);
1330 static inline void direct_dist_scale_factor(H264Context * const h){
1331 const int poc = h->s.current_picture_ptr->poc;
1332 const int poc1 = h->ref_list[1][0].poc;
1334 for(i=0; i<h->ref_count[0]; i++){
1335 int poc0 = h->ref_list[0][i].poc;
1336 int td = clip(poc1 - poc0, -128, 127);
1337 if(td == 0 /* FIXME || pic0 is a long-term ref */){
1338 h->dist_scale_factor[i] = 256;
1340 int tb = clip(poc - poc0, -128, 127);
1341 int tx = (16384 + (FFABS(td) >> 1)) / td;
1342 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023);
1346 for(i=0; i<h->ref_count[0]; i++){
1347 h->dist_scale_factor_field[2*i] =
1348 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i];
1352 static inline void direct_ref_list_init(H264Context * const h){
1353 MpegEncContext * const s = &h->s;
1354 Picture * const ref1 = &h->ref_list[1][0];
1355 Picture * const cur = s->current_picture_ptr;
1357 if(cur->pict_type == I_TYPE)
1358 cur->ref_count[0] = 0;
1359 if(cur->pict_type != B_TYPE)
1360 cur->ref_count[1] = 0;
1361 for(list=0; list<2; list++){
1362 cur->ref_count[list] = h->ref_count[list];
1363 for(j=0; j<h->ref_count[list]; j++)
1364 cur->ref_poc[list][j] = h->ref_list[list][j].poc;
1366 if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred)
1368 for(list=0; list<2; list++){
1369 for(i=0; i<ref1->ref_count[list]; i++){
1370 const int poc = ref1->ref_poc[list][i];
1371 h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */
1372 for(j=0; j<h->ref_count[list]; j++)
1373 if(h->ref_list[list][j].poc == poc){
1374 h->map_col_to_list0[list][i] = j;
1380 for(list=0; list<2; list++){
1381 for(i=0; i<ref1->ref_count[list]; i++){
1382 j = h->map_col_to_list0[list][i];
1383 h->map_col_to_list0_field[list][2*i] = 2*j;
1384 h->map_col_to_list0_field[list][2*i+1] = 2*j+1;
1390 static inline void pred_direct_motion(H264Context * const h, int *mb_type){
1391 MpegEncContext * const s = &h->s;
1392 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1393 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride;
1394 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
1395 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy];
1396 const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy];
1397 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy];
1398 const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy];
1399 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy];
1400 const int is_b8x8 = IS_8X8(*mb_type);
1404 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
1405 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){
1406 /* FIXME save sub mb types from previous frames (or derive from MVs)
1407 * so we know exactly what block size to use */
1408 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
1409 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
1410 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){
1411 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1412 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
1414 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1415 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
1418 *mb_type |= MB_TYPE_DIRECT2;
1420 *mb_type |= MB_TYPE_INTERLACED;
1422 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);
1424 if(h->direct_spatial_mv_pred){
1429 /* FIXME interlacing + spatial direct uses wrong colocated block positions */
1431 /* ref = min(neighbors) */
1432 for(list=0; list<2; list++){
1433 int refa = h->ref_cache[list][scan8[0] - 1];
1434 int refb = h->ref_cache[list][scan8[0] - 8];
1435 int refc = h->ref_cache[list][scan8[0] - 8 + 4];
1437 refc = h->ref_cache[list][scan8[0] - 8 - 1];
1439 if(ref[list] < 0 || (refb < ref[list] && refb >= 0))
1441 if(ref[list] < 0 || (refc < ref[list] && refc >= 0))
1447 if(ref[0] < 0 && ref[1] < 0){
1448 ref[0] = ref[1] = 0;
1449 mv[0][0] = mv[0][1] =
1450 mv[1][0] = mv[1][1] = 0;
1452 for(list=0; list<2; list++){
1454 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
1456 mv[list][0] = mv[list][1] = 0;
1461 *mb_type &= ~MB_TYPE_P0L1;
1462 sub_mb_type &= ~MB_TYPE_P0L1;
1463 }else if(ref[0] < 0){
1464 *mb_type &= ~MB_TYPE_P0L0;
1465 sub_mb_type &= ~MB_TYPE_P0L0;
1468 if(IS_16X16(*mb_type)){
1469 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
1470 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
1471 if(!IS_INTRA(mb_type_col)
1472 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
1473 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
1474 && (h->x264_build>33 || !h->x264_build)))){
1476 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1478 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1480 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1482 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1484 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1485 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1488 for(i8=0; i8<4; i8++){
1489 const int x8 = i8&1;
1490 const int y8 = i8>>1;
1492 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1494 h->sub_mb_type[i8] = sub_mb_type;
1496 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1497 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1498 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
1499 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1502 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0
1503 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0
1504 && (h->x264_build>33 || !h->x264_build)))){
1505 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1;
1506 if(IS_SUB_8X8(sub_mb_type)){
1507 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
1508 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1510 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1512 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1515 for(i4=0; i4<4; i4++){
1516 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
1517 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1519 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
1521 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
1527 }else{ /* direct temporal mv pred */
1528 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
1529 const int *dist_scale_factor = h->dist_scale_factor;
1532 if(IS_INTERLACED(*mb_type)){
1533 map_col_to_list0[0] = h->map_col_to_list0_field[0];
1534 map_col_to_list0[1] = h->map_col_to_list0_field[1];
1535 dist_scale_factor = h->dist_scale_factor_field;
1537 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){
1538 /* FIXME assumes direct_8x8_inference == 1 */
1539 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride;
1540 int mb_types_col[2];
1543 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1
1544 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2)
1545 | (*mb_type & MB_TYPE_INTERLACED);
1546 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16;
1548 if(IS_INTERLACED(*mb_type)){
1549 /* frame to field scaling */
1550 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy];
1551 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];
1553 l1ref0 -= 2*h->b8_stride;
1554 l1ref1 -= 2*h->b8_stride;
1555 l1mv0 -= 4*h->b_stride;
1556 l1mv1 -= 4*h->b_stride;
1560 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA)
1561 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA)
1563 *mb_type |= MB_TYPE_16x8;
1565 *mb_type |= MB_TYPE_8x8;
1567 /* field to frame scaling */
1568 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1)
1569 * but in MBAFF, top and bottom POC are equal */
1570 int dy = (s->mb_y&1) ? 1 : 2;
1572 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];
1573 l1ref0 += dy*h->b8_stride;
1574 l1ref1 += dy*h->b8_stride;
1575 l1mv0 += 2*dy*h->b_stride;
1576 l1mv1 += 2*dy*h->b_stride;
1579 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8))
1581 *mb_type |= MB_TYPE_16x16;
1583 *mb_type |= MB_TYPE_8x8;
1586 for(i8=0; i8<4; i8++){
1587 const int x8 = i8&1;
1588 const int y8 = i8>>1;
1590 const int16_t (*l1mv)[2]= l1mv0;
1592 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1594 h->sub_mb_type[i8] = sub_mb_type;
1596 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1597 if(IS_INTRA(mb_types_col[y8])){
1598 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
1599 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1600 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1604 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride];
1606 ref0 = map_col_to_list0[0][ref0*2>>y_shift];
1608 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift];
1611 scale = dist_scale_factor[ref0];
1612 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1615 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride];
1616 int my_col = (mv_col[1]<<y_shift)/2;
1617 int mx = (scale * mv_col[0] + 128) >> 8;
1618 int my = (scale * my_col + 128) >> 8;
1619 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
1620 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);
1627 /* one-to-one mv scaling */
1629 if(IS_16X16(*mb_type)){
1630 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
1631 if(IS_INTRA(mb_type_col)){
1632 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
1633 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1634 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1636 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]]
1637 : map_col_to_list0[1][l1ref1[0]];
1638 const int scale = dist_scale_factor[ref0];
1639 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
1641 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
1642 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1643 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1);
1644 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4);
1645 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4);
1648 for(i8=0; i8<4; i8++){
1649 const int x8 = i8&1;
1650 const int y8 = i8>>1;
1652 const int16_t (*l1mv)[2]= l1mv0;
1654 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1656 h->sub_mb_type[i8] = sub_mb_type;
1657 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1658 if(IS_INTRA(mb_type_col)){
1659 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
1660 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1661 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1665 ref0 = l1ref0[x8 + y8*h->b8_stride];
1667 ref0 = map_col_to_list0[0][ref0];
1669 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]];
1672 scale = dist_scale_factor[ref0];
1674 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1675 if(IS_SUB_8X8(sub_mb_type)){
1676 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
1677 int mx = (scale * mv_col[0] + 128) >> 8;
1678 int my = (scale * mv_col[1] + 128) >> 8;
1679 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
1680 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
1682 for(i4=0; i4<4; i4++){
1683 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
1684 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
1685 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
1686 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1687 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
1688 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
1695 static inline void write_back_motion(H264Context *h, int mb_type){
1696 MpegEncContext * const s = &h->s;
1697 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
1698 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
1701 if(!USES_LIST(mb_type, 0))
1702 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);
1704 for(list=0; list<2; list++){
1706 if(!USES_LIST(mb_type, list))
1710 *(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];
1711 *(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];
1713 if( h->pps.cabac ) {
1714 if(IS_SKIP(mb_type))
1715 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4);
1718 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
1719 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
1724 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];
1725 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];
1726 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];
1727 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];
1728 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];
1732 if(h->slice_type == B_TYPE && h->pps.cabac){
1733 if(IS_8X8(mb_type)){
1734 uint8_t *direct_table = &h->direct_table[b8_xy];
1735 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
1736 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
1737 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
1743 * Decodes a network abstraction layer unit.
1744 * @param consumed is the number of bytes used as input
1745 * @param length is the length of the array
1746 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
1747 * @returns decoded bytes, might be src+1 if no escapes
1749 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){
1753 // src[0]&0x80; //forbidden bit
1754 h->nal_ref_idc= src[0]>>5;
1755 h->nal_unit_type= src[0]&0x1F;
1759 for(i=0; i<length; i++)
1760 printf("%2X ", src[i]);
1762 for(i=0; i+1<length; i+=2){
1763 if(src[i]) continue;
1764 if(i>0 && src[i-1]==0) i--;
1765 if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1767 /* startcode, so we must be past the end */
1774 if(i>=length-1){ //no escaped 0
1775 *dst_length= length;
1776 *consumed= length+1; //+1 for the header
1780 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);
1781 dst= h->rbsp_buffer;
1787 //printf("decoding esc\n");
1790 //remove escapes (very rare 1:2^22)
1791 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1792 if(src[si+2]==3){ //escape
1797 }else //next start code
1801 dst[di++]= src[si++];
1805 *consumed= si + 1;//+1 for the header
1806 //FIXME store exact number of bits in the getbitcontext (its needed for decoding)
1811 * identifies the exact end of the bitstream
1812 * @return the length of the trailing, or 0 if damaged
1814 static int decode_rbsp_trailing(uint8_t *src){
1818 tprintf("rbsp trailing %X\n", v);
1828 * idct tranforms the 16 dc values and dequantize them.
1829 * @param qp quantization parameter
1831 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1834 int temp[16]; //FIXME check if this is a good idea
1835 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1836 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1838 //memset(block, 64, 2*256);
1841 const int offset= y_offset[i];
1842 const int z0= block[offset+stride*0] + block[offset+stride*4];
1843 const int z1= block[offset+stride*0] - block[offset+stride*4];
1844 const int z2= block[offset+stride*1] - block[offset+stride*5];
1845 const int z3= block[offset+stride*1] + block[offset+stride*5];
1854 const int offset= x_offset[i];
1855 const int z0= temp[4*0+i] + temp[4*2+i];
1856 const int z1= temp[4*0+i] - temp[4*2+i];
1857 const int z2= temp[4*1+i] - temp[4*3+i];
1858 const int z3= temp[4*1+i] + temp[4*3+i];
1860 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual
1861 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
1862 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
1863 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
1869 * dct tranforms the 16 dc values.
1870 * @param qp quantization parameter ??? FIXME
1872 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
1873 // const int qmul= dequant_coeff[qp][0];
1875 int temp[16]; //FIXME check if this is a good idea
1876 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1877 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1880 const int offset= y_offset[i];
1881 const int z0= block[offset+stride*0] + block[offset+stride*4];
1882 const int z1= block[offset+stride*0] - block[offset+stride*4];
1883 const int z2= block[offset+stride*1] - block[offset+stride*5];
1884 const int z3= block[offset+stride*1] + block[offset+stride*5];
1893 const int offset= x_offset[i];
1894 const int z0= temp[4*0+i] + temp[4*2+i];
1895 const int z1= temp[4*0+i] - temp[4*2+i];
1896 const int z2= temp[4*1+i] - temp[4*3+i];
1897 const int z3= temp[4*1+i] + temp[4*3+i];
1899 block[stride*0 +offset]= (z0 + z3)>>1;
1900 block[stride*2 +offset]= (z1 + z2)>>1;
1901 block[stride*8 +offset]= (z1 - z2)>>1;
1902 block[stride*10+offset]= (z0 - z3)>>1;
1910 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1911 const int stride= 16*2;
1912 const int xStride= 16;
1915 a= block[stride*0 + xStride*0];
1916 b= block[stride*0 + xStride*1];
1917 c= block[stride*1 + xStride*0];
1918 d= block[stride*1 + xStride*1];
1925 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
1926 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
1927 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
1928 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
1932 static void chroma_dc_dct_c(DCTELEM *block){
1933 const int stride= 16*2;
1934 const int xStride= 16;
1937 a= block[stride*0 + xStride*0];
1938 b= block[stride*0 + xStride*1];
1939 c= block[stride*1 + xStride*0];
1940 d= block[stride*1 + xStride*1];
1947 block[stride*0 + xStride*0]= (a+c);
1948 block[stride*0 + xStride*1]= (e+b);
1949 block[stride*1 + xStride*0]= (a-c);
1950 block[stride*1 + xStride*1]= (e-b);
1955 * gets the chroma qp.
1957 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){
1959 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)];
1962 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
1963 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)
1964 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){
1966 const int * const quant_table= quant_coeff[qscale];
1967 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
1968 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
1969 const unsigned int threshold2= (threshold1<<1);
1975 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
1976 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
1977 const unsigned int dc_threshold2= (dc_threshold1<<1);
1979 int level= block[0]*quant_coeff[qscale+18][0];
1980 if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1982 level= (dc_bias + level)>>(QUANT_SHIFT-2);
1985 level= (dc_bias - level)>>(QUANT_SHIFT-2);
1988 // last_non_zero = i;
1993 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
1994 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
1995 const unsigned int dc_threshold2= (dc_threshold1<<1);
1997 int level= block[0]*quant_table[0];
1998 if(((unsigned)(level+dc_threshold1))>dc_threshold2){
2000 level= (dc_bias + level)>>(QUANT_SHIFT+1);
2003 level= (dc_bias - level)>>(QUANT_SHIFT+1);
2006 // last_non_zero = i;
2019 const int j= scantable[i];
2020 int level= block[j]*quant_table[j];
2022 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
2023 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
2024 if(((unsigned)(level+threshold1))>threshold2){
2026 level= (bias + level)>>QUANT_SHIFT;
2029 level= (bias - level)>>QUANT_SHIFT;
2038 return last_non_zero;
2041 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){
2042 const uint32_t a= ((uint32_t*)(src-stride))[0];
2043 ((uint32_t*)(src+0*stride))[0]= a;
2044 ((uint32_t*)(src+1*stride))[0]= a;
2045 ((uint32_t*)(src+2*stride))[0]= a;
2046 ((uint32_t*)(src+3*stride))[0]= a;
2049 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){
2050 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;
2051 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;
2052 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;
2053 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;
2056 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){
2057 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
2058 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
2060 ((uint32_t*)(src+0*stride))[0]=
2061 ((uint32_t*)(src+1*stride))[0]=
2062 ((uint32_t*)(src+2*stride))[0]=
2063 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
2066 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){
2067 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
2069 ((uint32_t*)(src+0*stride))[0]=
2070 ((uint32_t*)(src+1*stride))[0]=
2071 ((uint32_t*)(src+2*stride))[0]=
2072 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
2075 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){
2076 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
2078 ((uint32_t*)(src+0*stride))[0]=
2079 ((uint32_t*)(src+1*stride))[0]=
2080 ((uint32_t*)(src+2*stride))[0]=
2081 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
2084 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){
2085 ((uint32_t*)(src+0*stride))[0]=
2086 ((uint32_t*)(src+1*stride))[0]=
2087 ((uint32_t*)(src+2*stride))[0]=
2088 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;
2092 #define LOAD_TOP_RIGHT_EDGE\
2093 const int t4= topright[0];\
2094 const int t5= topright[1];\
2095 const int t6= topright[2];\
2096 const int t7= topright[3];\
2098 #define LOAD_LEFT_EDGE\
2099 const int l0= src[-1+0*stride];\
2100 const int l1= src[-1+1*stride];\
2101 const int l2= src[-1+2*stride];\
2102 const int l3= src[-1+3*stride];\
2104 #define LOAD_TOP_EDGE\
2105 const int t0= src[ 0-1*stride];\
2106 const int t1= src[ 1-1*stride];\
2107 const int t2= src[ 2-1*stride];\
2108 const int t3= src[ 3-1*stride];\
2110 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){
2111 const int lt= src[-1-1*stride];
2115 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
2117 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
2120 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
2124 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
2127 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
2129 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2130 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
2133 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){
2138 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
2140 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
2143 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
2147 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
2150 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
2152 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
2153 src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
2156 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){
2157 const int lt= src[-1-1*stride];
2160 const __attribute__((unused)) int unu= l3;
2163 src[1+2*stride]=(lt + t0 + 1)>>1;
2165 src[2+2*stride]=(t0 + t1 + 1)>>1;
2167 src[3+2*stride]=(t1 + t2 + 1)>>1;
2168 src[3+0*stride]=(t2 + t3 + 1)>>1;
2170 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
2172 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
2174 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2175 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
2176 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
2177 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2180 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){
2183 const __attribute__((unused)) int unu= t7;
2185 src[0+0*stride]=(t0 + t1 + 1)>>1;
2187 src[0+2*stride]=(t1 + t2 + 1)>>1;
2189 src[1+2*stride]=(t2 + t3 + 1)>>1;
2191 src[2+2*stride]=(t3 + t4+ 1)>>1;
2192 src[3+2*stride]=(t4 + t5+ 1)>>1;
2193 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2195 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
2197 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
2199 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
2200 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
2203 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){
2206 src[0+0*stride]=(l0 + l1 + 1)>>1;
2207 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2209 src[0+1*stride]=(l1 + l2 + 1)>>1;
2211 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
2213 src[0+2*stride]=(l2 + l3 + 1)>>1;
2215 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
2224 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){
2225 const int lt= src[-1-1*stride];
2228 const __attribute__((unused)) int unu= t3;
2231 src[2+1*stride]=(lt + l0 + 1)>>1;
2233 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
2234 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
2235 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2237 src[2+2*stride]=(l0 + l1 + 1)>>1;
2239 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
2241 src[2+3*stride]=(l1 + l2+ 1)>>1;
2243 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2244 src[0+3*stride]=(l2 + l3 + 1)>>1;
2245 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
2248 void ff_pred16x16_vertical_c(uint8_t *src, int stride){
2250 const uint32_t a= ((uint32_t*)(src-stride))[0];
2251 const uint32_t b= ((uint32_t*)(src-stride))[1];
2252 const uint32_t c= ((uint32_t*)(src-stride))[2];
2253 const uint32_t d= ((uint32_t*)(src-stride))[3];
2255 for(i=0; i<16; i++){
2256 ((uint32_t*)(src+i*stride))[0]= a;
2257 ((uint32_t*)(src+i*stride))[1]= b;
2258 ((uint32_t*)(src+i*stride))[2]= c;
2259 ((uint32_t*)(src+i*stride))[3]= d;
2263 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){
2266 for(i=0; i<16; i++){
2267 ((uint32_t*)(src+i*stride))[0]=
2268 ((uint32_t*)(src+i*stride))[1]=
2269 ((uint32_t*)(src+i*stride))[2]=
2270 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;
2274 void ff_pred16x16_dc_c(uint8_t *src, int stride){
2278 dc+= src[-1+i*stride];
2285 dc= 0x01010101*((dc + 16)>>5);
2287 for(i=0; i<16; i++){
2288 ((uint32_t*)(src+i*stride))[0]=
2289 ((uint32_t*)(src+i*stride))[1]=
2290 ((uint32_t*)(src+i*stride))[2]=
2291 ((uint32_t*)(src+i*stride))[3]= dc;
2295 static void pred16x16_left_dc_c(uint8_t *src, int stride){
2299 dc+= src[-1+i*stride];
2302 dc= 0x01010101*((dc + 8)>>4);
2304 for(i=0; i<16; i++){
2305 ((uint32_t*)(src+i*stride))[0]=
2306 ((uint32_t*)(src+i*stride))[1]=
2307 ((uint32_t*)(src+i*stride))[2]=
2308 ((uint32_t*)(src+i*stride))[3]= dc;
2312 static void pred16x16_top_dc_c(uint8_t *src, int stride){
2318 dc= 0x01010101*((dc + 8)>>4);
2320 for(i=0; i<16; i++){
2321 ((uint32_t*)(src+i*stride))[0]=
2322 ((uint32_t*)(src+i*stride))[1]=
2323 ((uint32_t*)(src+i*stride))[2]=
2324 ((uint32_t*)(src+i*stride))[3]= dc;
2328 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){
2331 for(i=0; i<16; i++){
2332 ((uint32_t*)(src+i*stride))[0]=
2333 ((uint32_t*)(src+i*stride))[1]=
2334 ((uint32_t*)(src+i*stride))[2]=
2335 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;
2339 static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
2342 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2343 const uint8_t * const src0 = src+7-stride;
2344 const uint8_t *src1 = src+8*stride-1;
2345 const uint8_t *src2 = src1-2*stride; // == src+6*stride-1;
2346 int H = src0[1] - src0[-1];
2347 int V = src1[0] - src2[ 0];
2348 for(k=2; k<=8; ++k) {
2349 src1 += stride; src2 -= stride;
2350 H += k*(src0[k] - src0[-k]);
2351 V += k*(src1[0] - src2[ 0]);
2354 H = ( 5*(H/4) ) / 16;
2355 V = ( 5*(V/4) ) / 16;
2357 /* required for 100% accuracy */
2358 i = H; H = V; V = i;
2360 H = ( 5*H+32 ) >> 6;
2361 V = ( 5*V+32 ) >> 6;
2364 a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
2365 for(j=16; j>0; --j) {
2368 for(i=-16; i<0; i+=4) {
2369 src[16+i] = cm[ (b ) >> 5 ];
2370 src[17+i] = cm[ (b+ H) >> 5 ];
2371 src[18+i] = cm[ (b+2*H) >> 5 ];
2372 src[19+i] = cm[ (b+3*H) >> 5 ];
2379 void ff_pred16x16_plane_c(uint8_t *src, int stride){
2380 pred16x16_plane_compat_c(src, stride, 0);
2383 void ff_pred8x8_vertical_c(uint8_t *src, int stride){
2385 const uint32_t a= ((uint32_t*)(src-stride))[0];
2386 const uint32_t b= ((uint32_t*)(src-stride))[1];
2389 ((uint32_t*)(src+i*stride))[0]= a;
2390 ((uint32_t*)(src+i*stride))[1]= b;
2394 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){
2398 ((uint32_t*)(src+i*stride))[0]=
2399 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;
2403 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){
2407 ((uint32_t*)(src+i*stride))[0]=
2408 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
2412 static void pred8x8_left_dc_c(uint8_t *src, int stride){
2418 dc0+= src[-1+i*stride];
2419 dc2+= src[-1+(i+4)*stride];
2421 dc0= 0x01010101*((dc0 + 2)>>2);
2422 dc2= 0x01010101*((dc2 + 2)>>2);
2425 ((uint32_t*)(src+i*stride))[0]=
2426 ((uint32_t*)(src+i*stride))[1]= dc0;
2429 ((uint32_t*)(src+i*stride))[0]=
2430 ((uint32_t*)(src+i*stride))[1]= dc2;
2434 static void pred8x8_top_dc_c(uint8_t *src, int stride){
2440 dc0+= src[i-stride];
2441 dc1+= src[4+i-stride];
2443 dc0= 0x01010101*((dc0 + 2)>>2);
2444 dc1= 0x01010101*((dc1 + 2)>>2);
2447 ((uint32_t*)(src+i*stride))[0]= dc0;
2448 ((uint32_t*)(src+i*stride))[1]= dc1;
2451 ((uint32_t*)(src+i*stride))[0]= dc0;
2452 ((uint32_t*)(src+i*stride))[1]= dc1;
2457 void ff_pred8x8_dc_c(uint8_t *src, int stride){
2459 int dc0, dc1, dc2, dc3;
2463 dc0+= src[-1+i*stride] + src[i-stride];
2464 dc1+= src[4+i-stride];
2465 dc2+= src[-1+(i+4)*stride];
2467 dc3= 0x01010101*((dc1 + dc2 + 4)>>3);
2468 dc0= 0x01010101*((dc0 + 4)>>3);
2469 dc1= 0x01010101*((dc1 + 2)>>2);
2470 dc2= 0x01010101*((dc2 + 2)>>2);
2473 ((uint32_t*)(src+i*stride))[0]= dc0;
2474 ((uint32_t*)(src+i*stride))[1]= dc1;
2477 ((uint32_t*)(src+i*stride))[0]= dc2;
2478 ((uint32_t*)(src+i*stride))[1]= dc3;
2482 void ff_pred8x8_plane_c(uint8_t *src, int stride){
2485 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2486 const uint8_t * const src0 = src+3-stride;
2487 const uint8_t *src1 = src+4*stride-1;
2488 const uint8_t *src2 = src1-2*stride; // == src+2*stride-1;
2489 int H = src0[1] - src0[-1];
2490 int V = src1[0] - src2[ 0];
2491 for(k=2; k<=4; ++k) {
2492 src1 += stride; src2 -= stride;
2493 H += k*(src0[k] - src0[-k]);
2494 V += k*(src1[0] - src2[ 0]);
2496 H = ( 17*H+16 ) >> 5;
2497 V = ( 17*V+16 ) >> 5;
2499 a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
2500 for(j=8; j>0; --j) {
2503 src[0] = cm[ (b ) >> 5 ];
2504 src[1] = cm[ (b+ H) >> 5 ];
2505 src[2] = cm[ (b+2*H) >> 5 ];
2506 src[3] = cm[ (b+3*H) >> 5 ];
2507 src[4] = cm[ (b+4*H) >> 5 ];
2508 src[5] = cm[ (b+5*H) >> 5 ];
2509 src[6] = cm[ (b+6*H) >> 5 ];
2510 src[7] = cm[ (b+7*H) >> 5 ];
2515 #define SRC(x,y) src[(x)+(y)*stride]
2517 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
2518 #define PREDICT_8x8_LOAD_LEFT \
2519 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
2520 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
2521 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
2522 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
2525 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
2526 #define PREDICT_8x8_LOAD_TOP \
2527 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
2528 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
2529 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
2530 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
2531 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
2534 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
2535 #define PREDICT_8x8_LOAD_TOPRIGHT \
2536 int t8, t9, t10, t11, t12, t13, t14, t15; \
2537 if(has_topright) { \
2538 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
2539 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
2540 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
2542 #define PREDICT_8x8_LOAD_TOPLEFT \
2543 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
2545 #define PREDICT_8x8_DC(v) \
2547 for( y = 0; y < 8; y++ ) { \
2548 ((uint32_t*)src)[0] = \
2549 ((uint32_t*)src)[1] = v; \
2553 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2555 PREDICT_8x8_DC(0x80808080);
2557 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2559 PREDICT_8x8_LOAD_LEFT;
2560 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;
2563 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2565 PREDICT_8x8_LOAD_TOP;
2566 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;
2569 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2571 PREDICT_8x8_LOAD_LEFT;
2572 PREDICT_8x8_LOAD_TOP;
2573 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7
2574 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;
2577 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2579 PREDICT_8x8_LOAD_LEFT;
2580 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\
2581 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y
2582 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
2585 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2588 PREDICT_8x8_LOAD_TOP;
2597 for( y = 1; y < 8; y++ )
2598 *(uint64_t*)(src+y*stride) = *(uint64_t*)src;
2600 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2602 PREDICT_8x8_LOAD_TOP;
2603 PREDICT_8x8_LOAD_TOPRIGHT;
2604 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
2605 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
2606 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
2607 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
2608 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
2609 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
2610 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;
2611 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;
2612 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;
2613 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
2614 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
2615 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
2616 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
2617 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
2618 SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
2620 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2622 PREDICT_8x8_LOAD_TOP;
2623 PREDICT_8x8_LOAD_LEFT;
2624 PREDICT_8x8_LOAD_TOPLEFT;
2625 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
2626 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
2627 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
2628 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
2629 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
2630 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
2631 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;
2632 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;
2633 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;
2634 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
2635 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
2636 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
2637 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
2638 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
2639 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
2642 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2644 PREDICT_8x8_LOAD_TOP;
2645 PREDICT_8x8_LOAD_LEFT;
2646 PREDICT_8x8_LOAD_TOPLEFT;
2647 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
2648 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
2649 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
2650 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
2651 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
2652 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
2653 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
2654 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
2655 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
2656 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
2657 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
2658 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
2659 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
2660 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
2661 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
2662 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
2663 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
2664 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
2665 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
2666 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
2667 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
2668 SRC(7,0)= (t6 + t7 + 1) >> 1;
2670 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2672 PREDICT_8x8_LOAD_TOP;
2673 PREDICT_8x8_LOAD_LEFT;
2674 PREDICT_8x8_LOAD_TOPLEFT;
2675 SRC(0,7)= (l6 + l7 + 1) >> 1;
2676 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
2677 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
2678 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
2679 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
2680 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
2681 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
2682 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
2683 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
2684 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
2685 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
2686 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
2687 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
2688 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
2689 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
2690 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
2691 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
2692 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
2693 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
2694 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
2695 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
2696 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
2698 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2700 PREDICT_8x8_LOAD_TOP;
2701 PREDICT_8x8_LOAD_TOPRIGHT;
2702 SRC(0,0)= (t0 + t1 + 1) >> 1;
2703 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
2704 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
2705 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
2706 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
2707 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
2708 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
2709 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
2710 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
2711 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
2712 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
2713 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
2714 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
2715 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
2716 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
2717 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
2718 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
2719 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
2720 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
2721 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
2722 SRC(7,6)= (t10 + t11 + 1) >> 1;
2723 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
2725 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2727 PREDICT_8x8_LOAD_LEFT;
2728 SRC(0,0)= (l0 + l1 + 1) >> 1;
2729 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
2730 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
2731 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
2732 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
2733 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
2734 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
2735 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
2736 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
2737 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
2738 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
2739 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
2740 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
2741 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
2742 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
2743 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
2744 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
2745 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
2747 #undef PREDICT_8x8_LOAD_LEFT
2748 #undef PREDICT_8x8_LOAD_TOP
2749 #undef PREDICT_8x8_LOAD_TOPLEFT
2750 #undef PREDICT_8x8_LOAD_TOPRIGHT
2751 #undef PREDICT_8x8_DC
2757 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
2758 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2759 int src_x_offset, int src_y_offset,
2760 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
2761 MpegEncContext * const s = &h->s;
2762 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
2763 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
2764 const int luma_xy= (mx&3) + ((my&3)<<2);
2765 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
2766 uint8_t * src_cb, * src_cr;
2767 int extra_width= h->emu_edge_width;
2768 int extra_height= h->emu_edge_height;
2770 const int full_mx= mx>>2;
2771 const int full_my= my>>2;
2772 const int pic_width = 16*s->mb_width;
2773 const int pic_height = 16*s->mb_height >> MB_MBAFF;
2778 if(mx&7) extra_width -= 3;
2779 if(my&7) extra_height -= 3;
2781 if( full_mx < 0-extra_width
2782 || full_my < 0-extra_height
2783 || full_mx + 16/*FIXME*/ > pic_width + extra_width
2784 || full_my + 16/*FIXME*/ > pic_height + extra_height){
2785 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);
2786 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
2790 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
2792 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
2795 if(s->flags&CODEC_FLAG_GRAY) return;
2798 // chroma offset when predicting from a field of opposite parity
2799 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1));
2800 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
2802 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
2803 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
2806 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);
2807 src_cb= s->edge_emu_buffer;
2809 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
2812 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);
2813 src_cr= s->edge_emu_buffer;
2815 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
2818 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
2819 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2820 int x_offset, int y_offset,
2821 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2822 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
2823 int list0, int list1){
2824 MpegEncContext * const s = &h->s;
2825 qpel_mc_func *qpix_op= qpix_put;
2826 h264_chroma_mc_func chroma_op= chroma_put;
2828 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
2829 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
2830 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
2831 x_offset += 8*s->mb_x;
2832 y_offset += 8*(s->mb_y >> MB_MBAFF);
2835 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
2836 mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
2837 dest_y, dest_cb, dest_cr, x_offset, y_offset,
2838 qpix_op, chroma_op);
2841 chroma_op= chroma_avg;
2845 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
2846 mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
2847 dest_y, dest_cb, dest_cr, x_offset, y_offset,
2848 qpix_op, chroma_op);
2852 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
2853 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2854 int x_offset, int y_offset,
2855 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2856 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
2857 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
2858 int list0, int list1){
2859 MpegEncContext * const s = &h->s;
2861 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
2862 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
2863 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
2864 x_offset += 8*s->mb_x;
2865 y_offset += 8*(s->mb_y >> MB_MBAFF);
2868 /* don't optimize for luma-only case, since B-frames usually
2869 * use implicit weights => chroma too. */
2870 uint8_t *tmp_cb = s->obmc_scratchpad;
2871 uint8_t *tmp_cr = s->obmc_scratchpad + 8;
2872 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize;
2873 int refn0 = h->ref_cache[0][ scan8[n] ];
2874 int refn1 = h->ref_cache[1][ scan8[n] ];
2876 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
2877 dest_y, dest_cb, dest_cr,
2878 x_offset, y_offset, qpix_put, chroma_put);
2879 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
2880 tmp_y, tmp_cb, tmp_cr,
2881 x_offset, y_offset, qpix_put, chroma_put);
2883 if(h->use_weight == 2){
2884 int weight0 = h->implicit_weight[refn0][refn1];
2885 int weight1 = 64 - weight0;
2886 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);
2887 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
2888 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
2890 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
2891 h->luma_weight[0][refn0], h->luma_weight[1][refn1],
2892 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
2893 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
2894 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
2895 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
2896 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
2897 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
2898 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
2901 int list = list1 ? 1 : 0;
2902 int refn = h->ref_cache[list][ scan8[n] ];
2903 Picture *ref= &h->ref_list[list][refn];
2904 mc_dir_part(h, ref, n, square, chroma_height, delta, list,
2905 dest_y, dest_cb, dest_cr, x_offset, y_offset,
2906 qpix_put, chroma_put);
2908 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
2909 h->luma_weight[list][refn], h->luma_offset[list][refn]);
2910 if(h->use_weight_chroma){
2911 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
2912 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
2913 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
2914 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
2919 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
2920 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2921 int x_offset, int y_offset,
2922 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2923 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
2924 h264_weight_func *weight_op, h264_biweight_func *weight_avg,
2925 int list0, int list1){
2926 if((h->use_weight==2 && list0 && list1
2927 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
2928 || h->use_weight==1)
2929 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
2930 x_offset, y_offset, qpix_put, chroma_put,
2931 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
2933 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
2934 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
2937 static inline void prefetch_motion(H264Context *h, int list){
2938 /* fetch pixels for estimated mv 4 macroblocks ahead
2939 * optimized for 64byte cache lines */
2940 MpegEncContext * const s = &h->s;
2941 const int refn = h->ref_cache[list][scan8[0]];
2943 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
2944 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
2945 uint8_t **src= h->ref_list[list][refn].data;
2946 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
2947 s->dsp.prefetch(src[0]+off, s->linesize, 4);
2948 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
2949 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
2953 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2954 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
2955 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
2956 h264_weight_func *weight_op, h264_biweight_func *weight_avg){
2957 MpegEncContext * const s = &h->s;
2958 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
2959 const int mb_type= s->current_picture.mb_type[mb_xy];
2961 assert(IS_INTER(mb_type));
2963 prefetch_motion(h, 0);
2965 if(IS_16X16(mb_type)){
2966 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
2967 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
2968 &weight_op[0], &weight_avg[0],
2969 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2970 }else if(IS_16X8(mb_type)){
2971 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
2972 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2973 &weight_op[1], &weight_avg[1],
2974 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2975 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
2976 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2977 &weight_op[1], &weight_avg[1],
2978 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2979 }else if(IS_8X16(mb_type)){
2980 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
2981 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2982 &weight_op[2], &weight_avg[2],
2983 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2984 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
2985 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2986 &weight_op[2], &weight_avg[2],
2987 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2991 assert(IS_8X8(mb_type));
2994 const int sub_mb_type= h->sub_mb_type[i];
2996 int x_offset= (i&1)<<2;
2997 int y_offset= (i&2)<<1;
2999 if(IS_SUB_8X8(sub_mb_type)){
3000 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
3001 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
3002 &weight_op[3], &weight_avg[3],
3003 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3004 }else if(IS_SUB_8X4(sub_mb_type)){
3005 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
3006 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
3007 &weight_op[4], &weight_avg[4],
3008 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3009 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
3010 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
3011 &weight_op[4], &weight_avg[4],
3012 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3013 }else if(IS_SUB_4X8(sub_mb_type)){
3014 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
3015 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
3016 &weight_op[5], &weight_avg[5],
3017 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3018 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
3019 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
3020 &weight_op[5], &weight_avg[5],
3021 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3024 assert(IS_SUB_4X4(sub_mb_type));
3026 int sub_x_offset= x_offset + 2*(j&1);
3027 int sub_y_offset= y_offset + (j&2);
3028 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
3029 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
3030 &weight_op[6], &weight_avg[6],
3031 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
3037 prefetch_motion(h, 1);
3040 static void decode_init_vlc(){
3041 static int done = 0;
3047 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
3048 &chroma_dc_coeff_token_len [0], 1, 1,
3049 &chroma_dc_coeff_token_bits[0], 1, 1, 1);
3052 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
3053 &coeff_token_len [i][0], 1, 1,
3054 &coeff_token_bits[i][0], 1, 1, 1);
3058 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
3059 &chroma_dc_total_zeros_len [i][0], 1, 1,
3060 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1);
3062 for(i=0; i<15; i++){
3063 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16,
3064 &total_zeros_len [i][0], 1, 1,
3065 &total_zeros_bits[i][0], 1, 1, 1);
3069 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7,
3070 &run_len [i][0], 1, 1,
3071 &run_bits[i][0], 1, 1, 1);
3073 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
3074 &run_len [6][0], 1, 1,
3075 &run_bits[6][0], 1, 1, 1);
3080 * Sets the intra prediction function pointers.
3082 static void init_pred_ptrs(H264Context *h){
3083 // MpegEncContext * const s = &h->s;
3085 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c;
3086 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c;
3087 h->pred4x4[DC_PRED ]= pred4x4_dc_c;
3088 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;
3089 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;
3090 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c;
3091 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c;
3092 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c;
3093 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c;
3094 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c;
3095 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c;
3096 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c;
3098 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c;
3099 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c;
3100 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c;
3101 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;
3102 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;
3103 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c;
3104 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c;
3105 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c;
3106 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c;
3107 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c;
3108 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c;
3109 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c;
3111 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c;
3112 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c;
3113 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c;
3114 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c;
3115 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;
3116 h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;
3117 h->pred8x8[DC_128_PRED8x8 ]= ff_pred8x8_128_dc_c;
3119 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c;
3120 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c;
3121 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c;
3122 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c;
3123 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;
3124 h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;
3125 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c;
3128 static void free_tables(H264Context *h){
3129 av_freep(&h->intra4x4_pred_mode);
3130 av_freep(&h->chroma_pred_mode_table);
3131 av_freep(&h->cbp_table);
3132 av_freep(&h->mvd_table[0]);
3133 av_freep(&h->mvd_table[1]);
3134 av_freep(&h->direct_table);
3135 av_freep(&h->non_zero_count);
3136 av_freep(&h->slice_table_base);
3137 av_freep(&h->top_borders[1]);
3138 av_freep(&h->top_borders[0]);
3139 h->slice_table= NULL;
3141 av_freep(&h->mb2b_xy);
3142 av_freep(&h->mb2b8_xy);
3144 av_freep(&h->s.obmc_scratchpad);
3147 static void init_dequant8_coeff_table(H264Context *h){
3149 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
3150 h->dequant8_coeff[0] = h->dequant8_buffer[0];
3151 h->dequant8_coeff[1] = h->dequant8_buffer[1];
3153 for(i=0; i<2; i++ ){
3154 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
3155 h->dequant8_coeff[1] = h->dequant8_buffer[0];
3159 for(q=0; q<52; q++){
3160 int shift = ff_div6[q];
3161 int idx = ff_rem6[q];
3163 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
3164 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
3165 h->pps.scaling_matrix8[i][x]) << shift;
3170 static void init_dequant4_coeff_table(H264Context *h){
3172 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
3173 for(i=0; i<6; i++ ){
3174 h->dequant4_coeff[i] = h->dequant4_buffer[i];
3176 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
3177 h->dequant4_coeff[i] = h->dequant4_buffer[j];
3184 for(q=0; q<52; q++){
3185 int shift = ff_div6[q] + 2;
3186 int idx = ff_rem6[q];
3188 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
3189 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
3190 h->pps.scaling_matrix4[i][x]) << shift;
3195 static void init_dequant_tables(H264Context *h){
3197 init_dequant4_coeff_table(h);
3198 if(h->pps.transform_8x8_mode)
3199 init_dequant8_coeff_table(h);
3200 if(h->sps.transform_bypass){
3203 h->dequant4_coeff[i][0][x] = 1<<6;
3204 if(h->pps.transform_8x8_mode)
3207 h->dequant8_coeff[i][0][x] = 1<<6;
3214 * needs width/height
3216 static int alloc_tables(H264Context *h){
3217 MpegEncContext * const s = &h->s;
3218 const int big_mb_num= s->mb_stride * (s->mb_height+1);
3221 CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t))
3223 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t))
3224 CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(uint8_t))
3225 CHECKED_ALLOCZ(h->top_borders[0] , s->mb_width * (16+8+8) * sizeof(uint8_t))
3226 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t))
3227 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
3229 if( h->pps.cabac ) {
3230 CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
3231 CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
3232 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
3233 CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
3236 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t));
3237 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
3239 CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t));
3240 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
3241 for(y=0; y<s->mb_height; y++){
3242 for(x=0; x<s->mb_width; x++){
3243 const int mb_xy= x + y*s->mb_stride;
3244 const int b_xy = 4*x + 4*y*h->b_stride;
3245 const int b8_xy= 2*x + 2*y*h->b8_stride;
3247 h->mb2b_xy [mb_xy]= b_xy;
3248 h->mb2b8_xy[mb_xy]= b8_xy;
3252 s->obmc_scratchpad = NULL;
3254 if(!h->dequant4_coeff[0])
3255 init_dequant_tables(h);
3263 static void common_init(H264Context *h){
3264 MpegEncContext * const s = &h->s;
3266 s->width = s->avctx->width;
3267 s->height = s->avctx->height;
3268 s->codec_id= s->avctx->codec->id;
3272 h->dequant_coeff_pps= -1;
3273 s->unrestricted_mv=1;
3274 s->decode=1; //FIXME
3276 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
3277 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
3280 static int decode_init(AVCodecContext *avctx){
3281 H264Context *h= avctx->priv_data;
3282 MpegEncContext * const s = &h->s;
3284 MPV_decode_defaults(s);
3289 s->out_format = FMT_H264;
3290 s->workaround_bugs= avctx->workaround_bugs;
3293 // s->decode_mb= ff_h263_decode_mb;
3295 avctx->pix_fmt= PIX_FMT_YUV420P;
3299 if(avctx->extradata_size > 0 && avctx->extradata &&
3300 *(char *)avctx->extradata == 1){
3310 static int frame_start(H264Context *h){
3311 MpegEncContext * const s = &h->s;
3314 if(MPV_frame_start(s, s->avctx) < 0)
3316 ff_er_frame_start(s);
3318 assert(s->linesize && s->uvlinesize);
3320 for(i=0; i<16; i++){
3321 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
3322 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
3325 h->block_offset[16+i]=
3326 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
3327 h->block_offset[24+16+i]=
3328 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
3331 /* can't be in alloc_tables because linesize isn't known there.
3332 * FIXME: redo bipred weight to not require extra buffer? */
3333 if(!s->obmc_scratchpad)
3334 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
3336 /* some macroblocks will be accessed before they're available */
3338 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(uint8_t));
3340 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
3344 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
3345 MpegEncContext * const s = &h->s;
3349 src_cb -= uvlinesize;
3350 src_cr -= uvlinesize;
3352 // There are two lines saved, the line above the the top macroblock of a pair,
3353 // and the line above the bottom macroblock
3354 h->left_border[0]= h->top_borders[0][s->mb_x][15];
3355 for(i=1; i<17; i++){
3356 h->left_border[i]= src_y[15+i* linesize];
3359 *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
3360 *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
3362 if(!(s->flags&CODEC_FLAG_GRAY)){
3363 h->left_border[17 ]= h->top_borders[0][s->mb_x][16+7];
3364 h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7];
3366 h->left_border[i+17 ]= src_cb[7+i*uvlinesize];
3367 h->left_border[i+17+9]= src_cr[7+i*uvlinesize];
3369 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
3370 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
3374 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){
3375 MpegEncContext * const s = &h->s;
3378 int deblock_left = (s->mb_x > 0);
3379 int deblock_top = (s->mb_y > 0);
3381 src_y -= linesize + 1;
3382 src_cb -= uvlinesize + 1;
3383 src_cr -= uvlinesize + 1;
3385 #define XCHG(a,b,t,xchg)\
3392 for(i = !deblock_top; i<17; i++){
3393 XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
3398 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
3399 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
3400 if(s->mb_x+1 < s->mb_width){
3401 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
3405 if(!(s->flags&CODEC_FLAG_GRAY)){
3407 for(i = !deblock_top; i<9; i++){
3408 XCHG(h->left_border[i+17 ], src_cb[i*uvlinesize], temp8, xchg);
3409 XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);
3413 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
3414 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
3419 static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
3420 MpegEncContext * const s = &h->s;
3423 src_y -= 2 * linesize;
3424 src_cb -= 2 * uvlinesize;
3425 src_cr -= 2 * uvlinesize;
3427 // There are two lines saved, the line above the the top macroblock of a pair,
3428 // and the line above the bottom macroblock
3429 h->left_border[0]= h->top_borders[0][s->mb_x][15];
3430 h->left_border[1]= h->top_borders[1][s->mb_x][15];
3431 for(i=2; i<34; i++){
3432 h->left_border[i]= src_y[15+i* linesize];
3435 *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 32*linesize);
3436 *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize);
3437 *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y + 33*linesize);
3438 *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize);
3440 if(!(s->flags&CODEC_FLAG_GRAY)){
3441 h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7];
3442 h->left_border[34+ 1]= h->top_borders[1][s->mb_x][16+7];
3443 h->left_border[34+18 ]= h->top_borders[0][s->mb_x][24+7];
3444 h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7];
3445 for(i=2; i<18; i++){
3446 h->left_border[i+34 ]= src_cb[7+i*uvlinesize];
3447 h->left_border[i+34+18]= src_cr[7+i*uvlinesize];
3449 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize);
3450 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize);
3451 *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize);
3452 *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize);
3456 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){
3457 MpegEncContext * const s = &h->s;
3460 int deblock_left = (s->mb_x > 0);
3461 int deblock_top = (s->mb_y > 1);
3463 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);
3465 src_y -= 2 * linesize + 1;
3466 src_cb -= 2 * uvlinesize + 1;
3467 src_cr -= 2 * uvlinesize + 1;
3469 #define XCHG(a,b,t,xchg)\
3476 for(i = (!deblock_top)<<1; i<34; i++){
3477 XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
3482 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
3483 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
3484 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg);
3485 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1);
3486 if(s->mb_x+1 < s->mb_width){
3487 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
3488 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1);
3492 if(!(s->flags&CODEC_FLAG_GRAY)){
3494 for(i = (!deblock_top) << 1; i<18; i++){
3495 XCHG(h->left_border[i+34 ], src_cb[i*uvlinesize], temp8, xchg);
3496 XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg);
3500 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
3501 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
3502 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1);
3503 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1);
3508 static void hl_decode_mb(H264Context *h){
3509 MpegEncContext * const s = &h->s;
3510 const int mb_x= s->mb_x;
3511 const int mb_y= s->mb_y;
3512 const int mb_xy= mb_x + mb_y*s->mb_stride;
3513 const int mb_type= s->current_picture.mb_type[mb_xy];
3514 uint8_t *dest_y, *dest_cb, *dest_cr;
3515 int linesize, uvlinesize /*dct_offset*/;
3517 int *block_offset = &h->block_offset[0];
3518 const unsigned int bottom = mb_y & 1;
3519 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass);
3520 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
3521 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
3526 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
3527 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3528 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3530 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
3531 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
3534 linesize = h->mb_linesize = s->linesize * 2;
3535 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
3536 block_offset = &h->block_offset[24];
3537 if(mb_y&1){ //FIXME move out of this func?
3538 dest_y -= s->linesize*15;
3539 dest_cb-= s->uvlinesize*7;
3540 dest_cr-= s->uvlinesize*7;
3544 for(list=0; list<2; list++){
3545 if(!USES_LIST(mb_type, list))
3547 if(IS_16X16(mb_type)){
3548 int8_t *ref = &h->ref_cache[list][scan8[0]];
3549 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1);
3551 for(i=0; i<16; i+=4){
3552 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ?
3553 int ref = h->ref_cache[list][scan8[i]];
3555 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1);
3561 linesize = h->mb_linesize = s->linesize;
3562 uvlinesize = h->mb_uvlinesize = s->uvlinesize;
3563 // dct_offset = s->linesize * 16;
3566 if(transform_bypass){
3568 idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
3569 }else if(IS_8x8DCT(mb_type)){
3570 idct_dc_add = s->dsp.h264_idct8_dc_add;
3571 idct_add = s->dsp.h264_idct8_add;
3573 idct_dc_add = s->dsp.h264_idct_dc_add;
3574 idct_add = s->dsp.h264_idct_add;
3577 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type)
3578 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){
3579 int mbt_y = mb_y&~1;
3580 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16;
3581 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;
3582 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;
3583 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1);
3586 if (IS_INTRA_PCM(mb_type)) {
3589 // The pixels are stored in h->mb array in the same order as levels,
3590 // copy them in output in the correct order.
3591 for(i=0; i<16; i++) {
3592 for (y=0; y<4; y++) {
3593 for (x=0; x<4; x++) {
3594 *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x];
3598 for(i=16; i<16+4; i++) {
3599 for (y=0; y<4; y++) {
3600 for (x=0; x<4; x++) {
3601 *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
3605 for(i=20; i<20+4; i++) {
3606 for (y=0; y<4; y++) {
3607 for (x=0; x<4; x++) {
3608 *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
3613 if(IS_INTRA(mb_type)){
3614 if(h->deblocking_filter && !FRAME_MBAFF)
3615 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
3617 if(!(s->flags&CODEC_FLAG_GRAY)){
3618 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
3619 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
3622 if(IS_INTRA4x4(mb_type)){
3624 if(IS_8x8DCT(mb_type)){
3625 for(i=0; i<16; i+=4){
3626 uint8_t * const ptr= dest_y + block_offset[i];
3627 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
3628 const int nnz = h->non_zero_count_cache[ scan8[i] ];
3629 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
3630 (h->topright_samples_available<<(i+1))&0x8000, linesize);
3632 if(nnz == 1 && h->mb[i*16])
3633 idct_dc_add(ptr, h->mb + i*16, linesize);
3635 idct_add(ptr, h->mb + i*16, linesize);
3639 for(i=0; i<16; i++){
3640 uint8_t * const ptr= dest_y + block_offset[i];
3642 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
3645 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
3646 const int topright_avail= (h->topright_samples_available<<i)&0x8000;
3647 assert(mb_y || linesize <= block_offset[i]);
3648 if(!topright_avail){
3649 tr= ptr[3 - linesize]*0x01010101;
3650 topright= (uint8_t*) &tr;
3652 topright= ptr + 4 - linesize;
3656 h->pred4x4[ dir ](ptr, topright, linesize);
3657 nnz = h->non_zero_count_cache[ scan8[i] ];
3659 if(s->codec_id == CODEC_ID_H264){
3660 if(nnz == 1 && h->mb[i*16])
3661 idct_dc_add(ptr, h->mb + i*16, linesize);
3663 idct_add(ptr, h->mb + i*16, linesize);
3665 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
3670 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
3671 if(s->codec_id == CODEC_ID_H264){
3672 if(!transform_bypass)
3673 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]);
3675 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
3677 if(h->deblocking_filter && !FRAME_MBAFF)
3678 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
3679 }else if(s->codec_id == CODEC_ID_H264){
3680 hl_motion(h, dest_y, dest_cb, dest_cr,
3681 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
3682 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
3683 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
3687 if(!IS_INTRA4x4(mb_type)){
3688 if(s->codec_id == CODEC_ID_H264){
3689 if(IS_INTRA16x16(mb_type)){
3690 for(i=0; i<16; i++){
3691 if(h->non_zero_count_cache[ scan8[i] ])
3692 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
3693 else if(h->mb[i*16])
3694 idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
3697 const int di = IS_8x8DCT(mb_type) ? 4 : 1;
3698 for(i=0; i<16; i+=di){
3699 int nnz = h->non_zero_count_cache[ scan8[i] ];
3701 if(nnz==1 && h->mb[i*16])
3702 idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
3704 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
3709 for(i=0; i<16; i++){
3710 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
3711 uint8_t * const ptr= dest_y + block_offset[i];
3712 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
3718 if(!(s->flags&CODEC_FLAG_GRAY)){
3719 uint8_t *dest[2] = {dest_cb, dest_cr};
3720 if(transform_bypass){
3721 idct_add = idct_dc_add = s->dsp.add_pixels4;
3723 idct_add = s->dsp.h264_idct_add;
3724 idct_dc_add = s->dsp.h264_idct_dc_add;
3725 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp][0]);
3726 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp][0]);
3728 if(s->codec_id == CODEC_ID_H264){
3729 for(i=16; i<16+8; i++){
3730 if(h->non_zero_count_cache[ scan8[i] ])
3731 idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
3732 else if(h->mb[i*16])
3733 idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
3736 for(i=16; i<16+8; i++){
3737 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
3738 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
3739 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
3745 if(h->deblocking_filter) {
3747 //FIXME try deblocking one mb at a time?
3748 // the reduction in load/storing mvs and such might outweigh the extra backup/xchg_border
3749 const int mb_y = s->mb_y - 1;
3750 uint8_t *pair_dest_y, *pair_dest_cb, *pair_dest_cr;
3751 const int mb_xy= mb_x + mb_y*s->mb_stride;
3752 const int mb_type_top = s->current_picture.mb_type[mb_xy];
3753 const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride];
3754 if (!bottom) return;
3755 pair_dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
3756 pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3757 pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3759 if(IS_INTRA(mb_type_top | mb_type_bottom))
3760 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0);
3762 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize);
3766 tprintf("call mbaff filter_mb mb_x:%d mb_y:%d pair_dest_y = %p, dest_y = %p\n", mb_x, mb_y, pair_dest_y, dest_y);
3767 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb
3768 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy]);
3769 filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize);
3772 tprintf("call mbaff filter_mb\n");
3773 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb
3774 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy+s->mb_stride]);
3775 filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3777 tprintf("call filter_mb\n");
3778 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3779 fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
3780 filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3786 * fills the default_ref_list.
3788 static int fill_default_ref_list(H264Context *h){
3789 MpegEncContext * const s = &h->s;
3791 int smallest_poc_greater_than_current = -1;
3792 Picture sorted_short_ref[32];
3794 if(h->slice_type==B_TYPE){
3798 /* sort frame according to poc in B slice */
3799 for(out_i=0; out_i<h->short_ref_count; out_i++){
3801 int best_poc=INT_MAX;
3803 for(i=0; i<h->short_ref_count; i++){
3804 const int poc= h->short_ref[i]->poc;
3805 if(poc > limit && poc < best_poc){
3811 assert(best_i != INT_MIN);
3814 sorted_short_ref[out_i]= *h->short_ref[best_i];
3815 tprintf("sorted poc: %d->%d poc:%d fn:%d\n", best_i, out_i, sorted_short_ref[out_i].poc, sorted_short_ref[out_i].frame_num);
3816 if (-1 == smallest_poc_greater_than_current) {
3817 if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) {
3818 smallest_poc_greater_than_current = out_i;
3824 if(s->picture_structure == PICT_FRAME){
3825 if(h->slice_type==B_TYPE){
3827 tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current);
3829 // find the largest poc
3830 for(list=0; list<2; list++){
3833 int step= list ? -1 : 1;
3835 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) {
3836 while(j<0 || j>= h->short_ref_count){
3837 if(j != -99 && step == (list ? -1 : 1))
3840 j= smallest_poc_greater_than_current + (step>>1);
3842 if(sorted_short_ref[j].reference != 3) continue;
3843 h->default_ref_list[list][index ]= sorted_short_ref[j];
3844 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num;
3847 for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){
3848 if(h->long_ref[i] == NULL) continue;
3849 if(h->long_ref[i]->reference != 3) continue;
3851 h->default_ref_list[ list ][index ]= *h->long_ref[i];
3852 h->default_ref_list[ list ][index++].pic_id= i;;
3855 if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){
3856 // swap the two first elements of L1 when
3857 // L0 and L1 are identical
3858 Picture temp= h->default_ref_list[1][0];
3859 h->default_ref_list[1][0] = h->default_ref_list[1][1];
3860 h->default_ref_list[1][1] = temp;
3863 if(index < h->ref_count[ list ])
3864 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));
3868 for(i=0; i<h->short_ref_count; i++){
3869 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit
3870 h->default_ref_list[0][index ]= *h->short_ref[i];
3871 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;
3873 for(i = 0; i < 16; i++){
3874 if(h->long_ref[i] == NULL) continue;
3875 if(h->long_ref[i]->reference != 3) continue;
3876 h->default_ref_list[0][index ]= *h->long_ref[i];
3877 h->default_ref_list[0][index++].pic_id= i;;
3879 if(index < h->ref_count[0])
3880 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));
3883 if(h->slice_type==B_TYPE){
3885 //FIXME second field balh
3889 for (i=0; i<h->ref_count[0]; i++) {
3890 tprintf("List0: %s fn:%d 0x%p\n", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]);
3892 if(h->slice_type==B_TYPE){
3893 for (i=0; i<h->ref_count[1]; i++) {
3894 tprintf("List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[0][i].data[0]);
3901 static void print_short_term(H264Context *h);
3902 static void print_long_term(H264Context *h);
3904 static int decode_ref_pic_list_reordering(H264Context *h){
3905 MpegEncContext * const s = &h->s;
3908 print_short_term(h);
3910 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func
3912 for(list=0; list<2; list++){
3913 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
3915 if(get_bits1(&s->gb)){
3916 int pred= h->curr_pic_num;
3918 for(index=0; ; index++){
3919 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
3922 Picture *ref = NULL;
3924 if(reordering_of_pic_nums_idc==3)
3927 if(index >= h->ref_count[list]){
3928 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
3932 if(reordering_of_pic_nums_idc<3){
3933 if(reordering_of_pic_nums_idc<2){
3934 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
3936 if(abs_diff_pic_num >= h->max_pic_num){
3937 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
3941 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
3942 else pred+= abs_diff_pic_num;
3943 pred &= h->max_pic_num - 1;
3945 for(i= h->short_ref_count-1; i>=0; i--){
3946 ref = h->short_ref[i];
3947 assert(ref->reference == 3);
3948 assert(!ref->long_ref);
3949 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer
3953 ref->pic_id= ref->frame_num;
3955 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
3956 ref = h->long_ref[pic_id];
3958 ref->pic_id= pic_id;
3959 assert(ref->reference == 3);
3960 assert(ref->long_ref);
3968 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
3969 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
3971 for(i=index; i+1<h->ref_count[list]; i++){
3972 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
3975 for(; i > index; i--){
3976 h->ref_list[list][i]= h->ref_list[list][i-1];
3978 h->ref_list[list][index]= *ref;
3981 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
3987 if(h->slice_type!=B_TYPE) break;
3989 for(list=0; list<2; list++){
3990 for(index= 0; index < h->ref_count[list]; index++){
3991 if(!h->ref_list[list][index].data[0])
3992 h->ref_list[list][index]= s->current_picture;
3994 if(h->slice_type!=B_TYPE) break;
3997 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred)
3998 direct_dist_scale_factor(h);
3999 direct_ref_list_init(h);
4003 static void fill_mbaff_ref_list(H264Context *h){
4005 for(list=0; list<2; list++){
4006 for(i=0; i<h->ref_count[list]; i++){
4007 Picture *frame = &h->ref_list[list][i];
4008 Picture *field = &h->ref_list[list][16+2*i];
4011 field[0].linesize[j] <<= 1;
4012 field[1] = field[0];
4014 field[1].data[j] += frame->linesize[j];
4016 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i];
4017 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i];
4019 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j];
4020 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j];
4024 for(j=0; j<h->ref_count[1]; j++){
4025 for(i=0; i<h->ref_count[0]; i++)
4026 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i];
4027 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight));
4028 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight));
4032 static int pred_weight_table(H264Context *h){
4033 MpegEncContext * const s = &h->s;
4035 int luma_def, chroma_def;
4038 h->use_weight_chroma= 0;
4039 h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
4040 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
4041 luma_def = 1<<h->luma_log2_weight_denom;
4042 chroma_def = 1<<h->chroma_log2_weight_denom;
4044 for(list=0; list<2; list++){
4045 for(i=0; i<h->ref_count[list]; i++){
4046 int luma_weight_flag, chroma_weight_flag;
4048 luma_weight_flag= get_bits1(&s->gb);
4049 if(luma_weight_flag){
4050 h->luma_weight[list][i]= get_se_golomb(&s->gb);
4051 h->luma_offset[list][i]= get_se_golomb(&s->gb);
4052 if( h->luma_weight[list][i] != luma_def
4053 || h->luma_offset[list][i] != 0)
4056 h->luma_weight[list][i]= luma_def;
4057 h->luma_offset[list][i]= 0;
4060 chroma_weight_flag= get_bits1(&s->gb);
4061 if(chroma_weight_flag){
4064 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
4065 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
4066 if( h->chroma_weight[list][i][j] != chroma_def
4067 || h->chroma_offset[list][i][j] != 0)
4068 h->use_weight_chroma= 1;
4073 h->chroma_weight[list][i][j]= chroma_def;
4074 h->chroma_offset[list][i][j]= 0;
4078 if(h->slice_type != B_TYPE) break;
4080 h->use_weight= h->use_weight || h->use_weight_chroma;
4084 static void implicit_weight_table(H264Context *h){
4085 MpegEncContext * const s = &h->s;
4087 int cur_poc = s->current_picture_ptr->poc;
4089 if( h->ref_count[0] == 1 && h->ref_count[1] == 1
4090 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
4092 h->use_weight_chroma= 0;
4097 h->use_weight_chroma= 2;
4098 h->luma_log2_weight_denom= 5;
4099 h->chroma_log2_weight_denom= 5;
4101 for(ref0=0; ref0 < h->ref_count[0]; ref0++){
4102 int poc0 = h->ref_list[0][ref0].poc;
4103 for(ref1=0; ref1 < h->ref_count[1]; ref1++){
4104 int poc1 = h->ref_list[1][ref1].poc;
4105 int td = clip(poc1 - poc0, -128, 127);
4107 int tb = clip(cur_poc - poc0, -128, 127);
4108 int tx = (16384 + (FFABS(td) >> 1)) / td;
4109 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
4110 if(dist_scale_factor < -64 || dist_scale_factor > 128)
4111 h->implicit_weight[ref0][ref1] = 32;
4113 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
4115 h->implicit_weight[ref0][ref1] = 32;
4120 static inline void unreference_pic(H264Context *h, Picture *pic){
4123 if(pic == h->delayed_output_pic)
4126 for(i = 0; h->delayed_pic[i]; i++)
4127 if(pic == h->delayed_pic[i]){
4135 * instantaneous decoder refresh.
4137 static void idr(H264Context *h){
4140 for(i=0; i<16; i++){
4141 if (h->long_ref[i] != NULL) {
4142 unreference_pic(h, h->long_ref[i]);
4143 h->long_ref[i]= NULL;
4146 h->long_ref_count=0;
4148 for(i=0; i<h->short_ref_count; i++){
4149 unreference_pic(h, h->short_ref[i]);
4150 h->short_ref[i]= NULL;
4152 h->short_ref_count=0;
4155 /* forget old pics after a seek */
4156 static void flush_dpb(AVCodecContext *avctx){
4157 H264Context *h= avctx->priv_data;
4159 for(i=0; i<16; i++) {
4160 if(h->delayed_pic[i])
4161 h->delayed_pic[i]->reference= 0;
4162 h->delayed_pic[i]= NULL;
4164 if(h->delayed_output_pic)
4165 h->delayed_output_pic->reference= 0;
4166 h->delayed_output_pic= NULL;
4168 if(h->s.current_picture_ptr)
4169 h->s.current_picture_ptr->reference= 0;
4174 * @return the removed picture or NULL if an error occurs
4176 static Picture * remove_short(H264Context *h, int frame_num){
4177 MpegEncContext * const s = &h->s;
4180 if(s->avctx->debug&FF_DEBUG_MMCO)
4181 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
4183 for(i=0; i<h->short_ref_count; i++){
4184 Picture *pic= h->short_ref[i];
4185 if(s->avctx->debug&FF_DEBUG_MMCO)
4186 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
4187 if(pic->frame_num == frame_num){
4188 h->short_ref[i]= NULL;
4189 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
4190 h->short_ref_count--;
4199 * @return the removed picture or NULL if an error occurs
4201 static Picture * remove_long(H264Context *h, int i){
4204 pic= h->long_ref[i];
4205 h->long_ref[i]= NULL;
4206 if(pic) h->long_ref_count--;
4212 * print short term list
4214 static void print_short_term(H264Context *h) {
4216 if(h->s.avctx->debug&FF_DEBUG_MMCO) {
4217 av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");
4218 for(i=0; i<h->short_ref_count; i++){
4219 Picture *pic= h->short_ref[i];
4220 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
4226 * print long term list
4228 static void print_long_term(H264Context *h) {
4230 if(h->s.avctx->debug&FF_DEBUG_MMCO) {
4231 av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");
4232 for(i = 0; i < 16; i++){
4233 Picture *pic= h->long_ref[i];
4235 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
4242 * Executes the reference picture marking (memory management control operations).
4244 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
4245 MpegEncContext * const s = &h->s;
4247 int current_is_long=0;
4250 if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
4251 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
4253 for(i=0; i<mmco_count; i++){
4254 if(s->avctx->debug&FF_DEBUG_MMCO)
4255 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);
4257 switch(mmco[i].opcode){
4258 case MMCO_SHORT2UNUSED:
4259 pic= remove_short(h, mmco[i].short_frame_num);
4261 unreference_pic(h, pic);
4262 else if(s->avctx->debug&FF_DEBUG_MMCO)
4263 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n");
4265 case MMCO_SHORT2LONG:
4266 pic= remove_long(h, mmco[i].long_index);
4267 if(pic) unreference_pic(h, pic);
4269 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);
4270 if (h->long_ref[ mmco[i].long_index ]){
4271 h->long_ref[ mmco[i].long_index ]->long_ref=1;
4272 h->long_ref_count++;
4275 case MMCO_LONG2UNUSED:
4276 pic= remove_long(h, mmco[i].long_index);
4278 unreference_pic(h, pic);
4279 else if(s->avctx->debug&FF_DEBUG_MMCO)
4280 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n");
4283 pic= remove_long(h, mmco[i].long_index);
4284 if(pic) unreference_pic(h, pic);
4286 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;
4287 h->long_ref[ mmco[i].long_index ]->long_ref=1;
4288 h->long_ref_count++;
4292 case MMCO_SET_MAX_LONG:
4293 assert(mmco[i].long_index <= 16);
4294 // just remove the long term which index is greater than new max
4295 for(j = mmco[i].long_index; j<16; j++){
4296 pic = remove_long(h, j);
4297 if (pic) unreference_pic(h, pic);
4301 while(h->short_ref_count){
4302 pic= remove_short(h, h->short_ref[0]->frame_num);
4303 if(pic) unreference_pic(h, pic);
4305 for(j = 0; j < 16; j++) {
4306 pic= remove_long(h, j);
4307 if(pic) unreference_pic(h, pic);
4314 if(!current_is_long){
4315 pic= remove_short(h, s->current_picture_ptr->frame_num);
4317 unreference_pic(h, pic);
4318 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
4321 if(h->short_ref_count)
4322 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
4324 h->short_ref[0]= s->current_picture_ptr;
4325 h->short_ref[0]->long_ref=0;
4326 h->short_ref_count++;
4329 print_short_term(h);
4334 static int decode_ref_pic_marking(H264Context *h){
4335 MpegEncContext * const s = &h->s;
4338 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
4339 s->broken_link= get_bits1(&s->gb) -1;
4340 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx
4341 if(h->mmco[0].long_index == -1)
4344 h->mmco[0].opcode= MMCO_LONG;
4348 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag
4349 for(i= 0; i<MAX_MMCO_COUNT; i++) {
4350 MMCOOpcode opcode= get_ue_golomb(&s->gb);;
4352 h->mmco[i].opcode= opcode;
4353 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
4354 h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields
4355 /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){
4356 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);
4360 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
4361 h->mmco[i].long_index= get_ue_golomb(&s->gb);
4362 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){
4363 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
4368 if(opcode > MMCO_LONG){
4369 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
4372 if(opcode == MMCO_END)
4377 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
4379 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields
4380 h->mmco[0].opcode= MMCO_SHORT2UNUSED;
4381 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
4391 static int init_poc(H264Context *h){
4392 MpegEncContext * const s = &h->s;
4393 const int max_frame_num= 1<<h->sps.log2_max_frame_num;
4396 if(h->nal_unit_type == NAL_IDR_SLICE){
4397 h->frame_num_offset= 0;
4399 if(h->frame_num < h->prev_frame_num)
4400 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;
4402 h->frame_num_offset= h->prev_frame_num_offset;
4405 if(h->sps.poc_type==0){
4406 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
4408 if(h->nal_unit_type == NAL_IDR_SLICE){
4413 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
4414 h->poc_msb = h->prev_poc_msb + max_poc_lsb;
4415 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
4416 h->poc_msb = h->prev_poc_msb - max_poc_lsb;
4418 h->poc_msb = h->prev_poc_msb;
4419 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
4421 field_poc[1] = h->poc_msb + h->poc_lsb;
4422 if(s->picture_structure == PICT_FRAME)
4423 field_poc[1] += h->delta_poc_bottom;
4424 }else if(h->sps.poc_type==1){
4425 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
4428 if(h->sps.poc_cycle_length != 0)
4429 abs_frame_num = h->frame_num_offset + h->frame_num;
4433 if(h->nal_ref_idc==0 && abs_frame_num > 0)
4436 expected_delta_per_poc_cycle = 0;
4437 for(i=0; i < h->sps.poc_cycle_length; i++)
4438 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
4440 if(abs_frame_num > 0){
4441 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length;
4442 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
4444 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
4445 for(i = 0; i <= frame_num_in_poc_cycle; i++)
4446 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
4450 if(h->nal_ref_idc == 0)
4451 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
4453 field_poc[0] = expectedpoc + h->delta_poc[0];
4454 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
4456 if(s->picture_structure == PICT_FRAME)
4457 field_poc[1] += h->delta_poc[1];
4460 if(h->nal_unit_type == NAL_IDR_SLICE){
4463 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);
4464 else poc= 2*(h->frame_num_offset + h->frame_num) - 1;
4470 if(s->picture_structure != PICT_BOTTOM_FIELD)
4471 s->current_picture_ptr->field_poc[0]= field_poc[0];
4472 if(s->picture_structure != PICT_TOP_FIELD)
4473 s->current_picture_ptr->field_poc[1]= field_poc[1];
4474 if(s->picture_structure == PICT_FRAME) // FIXME field pix?
4475 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);
4481 * decodes a slice header.
4482 * this will allso call MPV_common_init() and frame_start() as needed
4484 static int decode_slice_header(H264Context *h){
4485 MpegEncContext * const s = &h->s;
4486 int first_mb_in_slice;
4487 unsigned int pps_id;
4488 int num_ref_idx_active_override_flag;
4489 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};
4491 int default_ref_list_done = 0;
4493 s->current_picture.reference= h->nal_ref_idc != 0;
4494 s->dropable= h->nal_ref_idc == 0;
4496 first_mb_in_slice= get_ue_golomb(&s->gb);
4498 slice_type= get_ue_golomb(&s->gb);
4500 av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
4505 h->slice_type_fixed=1;
4507 h->slice_type_fixed=0;
4509 slice_type= slice_type_map[ slice_type ];
4510 if (slice_type == I_TYPE
4511 || (h->slice_num != 0 && slice_type == h->slice_type) ) {
4512 default_ref_list_done = 1;
4514 h->slice_type= slice_type;
4516 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though
4518 pps_id= get_ue_golomb(&s->gb);
4519 if(pps_id>=MAX_PPS_COUNT){
4520 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
4523 h->pps= h->pps_buffer[pps_id];
4524 if(h->pps.slice_group_count == 0){
4525 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
4529 h->sps= h->sps_buffer[ h->pps.sps_id ];
4530 if(h->sps.log2_max_frame_num == 0){
4531 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
4535 if(h->dequant_coeff_pps != (int)pps_id){
4536 h->dequant_coeff_pps = (int)pps_id;
4537 init_dequant_tables(h);
4540 s->mb_width= h->sps.mb_width;
4541 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
4543 h->b_stride= s->mb_width*4;
4544 h->b8_stride= s->mb_width*2;
4546 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );
4547 if(h->sps.frame_mbs_only_flag)
4548 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom);
4550 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck
4552 if (s->context_initialized
4553 && ( s->width != s->avctx->width || s->height != s->avctx->height)) {
4557 if (!s->context_initialized) {
4558 if (MPV_common_init(s) < 0)
4561 if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
4562 memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
4563 memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t));
4566 for(i=0; i<16; i++){
4567 #define T(x) (x>>2) | ((x<<2) & 0xF)
4568 h->zigzag_scan[i] = T(zigzag_scan[i]);
4569 h-> field_scan[i] = T( field_scan[i]);
4573 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){
4574 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t));
4575 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
4576 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t));
4577 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t));
4580 for(i=0; i<64; i++){
4581 #define T(x) (x>>3) | ((x&7)<<3)
4582 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]);
4583 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
4584 h->field_scan8x8[i] = T(field_scan8x8[i]);
4585 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]);
4589 if(h->sps.transform_bypass){ //FIXME same ugly
4590 h->zigzag_scan_q0 = zigzag_scan;
4591 h->zigzag_scan8x8_q0 = zigzag_scan8x8;
4592 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
4593 h->field_scan_q0 = field_scan;
4594 h->field_scan8x8_q0 = field_scan8x8;
4595 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc;
4597 h->zigzag_scan_q0 = h->zigzag_scan;
4598 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8;
4599 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
4600 h->field_scan_q0 = h->field_scan;
4601 h->field_scan8x8_q0 = h->field_scan8x8;
4602 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc;
4607 s->avctx->width = s->width;
4608 s->avctx->height = s->height;
4609 s->avctx->sample_aspect_ratio= h->sps.sar;
4610 if(!s->avctx->sample_aspect_ratio.den)
4611 s->avctx->sample_aspect_ratio.den = 1;
4613 if(h->sps.timing_info_present_flag){
4614 s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
4615 if(h->x264_build > 0 && h->x264_build < 44)
4616 s->avctx->time_base.den *= 2;
4617 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
4618 s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);
4622 if(h->slice_num == 0){
4623 if(frame_start(h) < 0)
4627 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup
4628 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
4631 h->mb_aff_frame = 0;
4632 if(h->sps.frame_mbs_only_flag){
4633 s->picture_structure= PICT_FRAME;
4635 if(get_bits1(&s->gb)) { //field_pic_flag
4636 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
4637 av_log(h->s.avctx, AV_LOG_ERROR, "PAFF interlacing is not implemented\n");
4639 s->picture_structure= PICT_FRAME;
4640 h->mb_aff_frame = h->sps.mb_aff;
4644 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
4645 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame;
4646 if(s->mb_y >= s->mb_height){
4650 if(s->picture_structure==PICT_FRAME){
4651 h->curr_pic_num= h->frame_num;
4652 h->max_pic_num= 1<< h->sps.log2_max_frame_num;
4654 h->curr_pic_num= 2*h->frame_num;
4655 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
4658 if(h->nal_unit_type == NAL_IDR_SLICE){
4659 get_ue_golomb(&s->gb); /* idr_pic_id */
4662 if(h->sps.poc_type==0){
4663 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
4665 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
4666 h->delta_poc_bottom= get_se_golomb(&s->gb);
4670 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
4671 h->delta_poc[0]= get_se_golomb(&s->gb);
4673 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
4674 h->delta_poc[1]= get_se_golomb(&s->gb);
4679 if(h->pps.redundant_pic_cnt_present){
4680 h->redundant_pic_count= get_ue_golomb(&s->gb);
4683 //set defaults, might be overriden a few line later
4684 h->ref_count[0]= h->pps.ref_count[0];
4685 h->ref_count[1]= h->pps.ref_count[1];
4687 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){
4688 if(h->slice_type == B_TYPE){
4689 h->direct_spatial_mv_pred= get_bits1(&s->gb);
4690 if(h->sps.mb_aff && h->direct_spatial_mv_pred)
4691 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n");
4693 num_ref_idx_active_override_flag= get_bits1(&s->gb);
4695 if(num_ref_idx_active_override_flag){
4696 h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
4697 if(h->slice_type==B_TYPE)
4698 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
4700 if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
4701 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
4707 if(!default_ref_list_done){
4708 fill_default_ref_list(h);
4711 if(decode_ref_pic_list_reordering(h) < 0)
4714 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE ))
4715 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )
4716 pred_weight_table(h);
4717 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE)
4718 implicit_weight_table(h);
4722 if(s->current_picture.reference)
4723 decode_ref_pic_marking(h);
4726 fill_mbaff_ref_list(h);
4728 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )
4729 h->cabac_init_idc = get_ue_golomb(&s->gb);
4731 h->last_qscale_diff = 0;
4732 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);
4733 if(s->qscale<0 || s->qscale>51){
4734 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);
4737 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
4738 //FIXME qscale / qp ... stuff
4739 if(h->slice_type == SP_TYPE){
4740 get_bits1(&s->gb); /* sp_for_switch_flag */
4742 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){
4743 get_se_golomb(&s->gb); /* slice_qs_delta */
4746 h->deblocking_filter = 1;
4747 h->slice_alpha_c0_offset = 0;
4748 h->slice_beta_offset = 0;
4749 if( h->pps.deblocking_filter_parameters_present ) {
4750 h->deblocking_filter= get_ue_golomb(&s->gb);
4751 if(h->deblocking_filter < 2)
4752 h->deblocking_filter^= 1; // 1<->0
4754 if( h->deblocking_filter ) {
4755 h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
4756 h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
4759 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL
4760 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE)
4761 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE)
4762 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
4763 h->deblocking_filter= 0;
4766 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
4767 slice_group_change_cycle= get_bits(&s->gb, ?);
4772 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
4773 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width;
4775 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4776 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n",
4778 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
4780 av_get_pict_type_char(h->slice_type),
4781 pps_id, h->frame_num,
4782 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
4783 h->ref_count[0], h->ref_count[1],
4785 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
4787 h->use_weight==1 && h->use_weight_chroma ? "c" : ""
4791 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !s->current_picture.reference){
4792 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
4793 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
4795 s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
4796 s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
4805 static inline int get_level_prefix(GetBitContext *gb){
4809 OPEN_READER(re, gb);
4810 UPDATE_CACHE(re, gb);
4811 buf=GET_CACHE(re, gb);
4813 log= 32 - av_log2(buf);
4815 print_bin(buf>>(32-log), log);
4816 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
4819 LAST_SKIP_BITS(re, gb, log);
4820 CLOSE_READER(re, gb);
4825 static inline int get_dct8x8_allowed(H264Context *h){
4828 if(!IS_SUB_8X8(h->sub_mb_type[i])
4829 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
4836 * decodes a residual block.
4837 * @param n block index
4838 * @param scantable scantable
4839 * @param max_coeff number of coefficients in the block
4840 * @return <0 if an error occured
4842 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
4843 MpegEncContext * const s = &h->s;
4844 static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
4846 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
4848 //FIXME put trailing_onex into the context
4850 if(n == CHROMA_DC_BLOCK_INDEX){
4851 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
4852 total_coeff= coeff_token>>2;
4854 if(n == LUMA_DC_BLOCK_INDEX){
4855 total_coeff= pred_non_zero_count(h, 0);
4856 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
4857 total_coeff= coeff_token>>2;
4859 total_coeff= pred_non_zero_count(h, n);
4860 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
4861 total_coeff= coeff_token>>2;
4862 h->non_zero_count_cache[ scan8[n] ]= total_coeff;
4866 //FIXME set last_non_zero?
4871 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff<0)\n", s->mb_x, s->mb_y);
4875 trailing_ones= coeff_token&3;
4876 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);
4877 assert(total_coeff<=16);
4879 for(i=0; i<trailing_ones; i++){
4880 level[i]= 1 - 2*get_bits1(gb);
4884 int level_code, mask;
4885 int suffix_length = total_coeff > 10 && trailing_ones < 3;
4886 int prefix= get_level_prefix(gb);
4888 //first coefficient has suffix_length equal to 0 or 1
4889 if(prefix<14){ //FIXME try to build a large unified VLC table for all this
4891 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4893 level_code= (prefix<<suffix_length); //part
4894 }else if(prefix==14){
4896 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4898 level_code= prefix + get_bits(gb, 4); //part
4899 }else if(prefix==15){
4900 level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
4901 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
4903 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
4907 if(trailing_ones < 3) level_code += 2;
4912 mask= -(level_code&1);
4913 level[i]= (((2+level_code)>>1) ^ mask) - mask;
4916 //remaining coefficients have suffix_length > 0
4917 for(;i<total_coeff;i++) {
4918 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
4919 prefix = get_level_prefix(gb);
4921 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
4922 }else if(prefix==15){
4923 level_code = (prefix<<suffix_length) + get_bits(gb, 12);
4925 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
4928 mask= -(level_code&1);
4929 level[i]= (((2+level_code)>>1) ^ mask) - mask;
4930 if(level_code > suffix_limit[suffix_length])
4935 if(total_coeff == max_coeff)
4938 if(n == CHROMA_DC_BLOCK_INDEX)
4939 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
4941 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
4944 coeff_num = zeros_left + total_coeff - 1;
4945 j = scantable[coeff_num];
4947 block[j] = level[0];
4948 for(i=1;i<total_coeff;i++) {
4951 else if(zeros_left < 7){
4952 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
4954 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
4956 zeros_left -= run_before;
4957 coeff_num -= 1 + run_before;
4958 j= scantable[ coeff_num ];
4963 block[j] = (level[0] * qmul[j] + 32)>>6;
4964 for(i=1;i<total_coeff;i++) {
4967 else if(zeros_left < 7){
4968 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
4970 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
4972 zeros_left -= run_before;
4973 coeff_num -= 1 + run_before;
4974 j= scantable[ coeff_num ];
4976 block[j]= (level[i] * qmul[j] + 32)>>6;
4981 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
4988 static void predict_field_decoding_flag(H264Context *h){
4989 MpegEncContext * const s = &h->s;
4990 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
4991 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
4992 ? s->current_picture.mb_type[mb_xy-1]
4993 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
4994 ? s->current_picture.mb_type[mb_xy-s->mb_stride]
4996 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
5000 * decodes a P_SKIP or B_SKIP macroblock
5002 static void decode_mb_skip(H264Context *h){
5003 MpegEncContext * const s = &h->s;
5004 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
5007 memset(h->non_zero_count[mb_xy], 0, 16);
5008 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
5011 mb_type|= MB_TYPE_INTERLACED;
5013 if( h->slice_type == B_TYPE )
5015 // just for fill_caches. pred_direct_motion will set the real mb_type
5016 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
5018 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
5019 pred_direct_motion(h, &mb_type);
5020 mb_type|= MB_TYPE_SKIP;
5025 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
5027 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
5028 pred_pskip_motion(h, &mx, &my);
5029 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
5030 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
5033 write_back_motion(h, mb_type);
5034 s->current_picture.mb_type[mb_xy]= mb_type;
5035 s->current_picture.qscale_table[mb_xy]= s->qscale;
5036 h->slice_table[ mb_xy ]= h->slice_num;
5037 h->prev_mb_skipped= 1;
5041 * decodes a macroblock
5042 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
5044 static int decode_mb_cavlc(H264Context *h){
5045 MpegEncContext * const s = &h->s;
5046 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
5047 int mb_type, partition_count, cbp;
5048 int dct8x8_allowed= h->pps.transform_8x8_mode;
5050 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
5052 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
5053 cbp = 0; /* avoid warning. FIXME: find a solution without slowing
5055 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
5056 if(s->mb_skip_run==-1)
5057 s->mb_skip_run= get_ue_golomb(&s->gb);
5059 if (s->mb_skip_run--) {
5060 if(FRAME_MBAFF && (s->mb_y&1) == 0){
5061 if(s->mb_skip_run==0)
5062 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
5064 predict_field_decoding_flag(h);
5071 if( (s->mb_y&1) == 0 )
5072 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
5074 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
5076 h->prev_mb_skipped= 0;
5078 mb_type= get_ue_golomb(&s->gb);
5079 if(h->slice_type == B_TYPE){
5081 partition_count= b_mb_type_info[mb_type].partition_count;
5082 mb_type= b_mb_type_info[mb_type].type;
5085 goto decode_intra_mb;
5087 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
5089 partition_count= p_mb_type_info[mb_type].partition_count;
5090 mb_type= p_mb_type_info[mb_type].type;
5093 goto decode_intra_mb;
5096 assert(h->slice_type == I_TYPE);
5099 av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
5103 cbp= i_mb_type_info[mb_type].cbp;
5104 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
5105 mb_type= i_mb_type_info[mb_type].type;
5109 mb_type |= MB_TYPE_INTERLACED;
5111 h->slice_table[ mb_xy ]= h->slice_num;
5113 if(IS_INTRA_PCM(mb_type)){
5116 // we assume these blocks are very rare so we dont optimize it
5117 align_get_bits(&s->gb);
5119 // The pixels are stored in the same order as levels in h->mb array.
5120 for(y=0; y<16; y++){
5121 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
5122 for(x=0; x<16; x++){
5123 tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
5124 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);
5128 const int index= 256 + 4*(y&3) + 32*(y>>2);
5130 tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
5131 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
5135 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
5137 tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
5138 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
5142 // In deblocking, the quantizer is 0
5143 s->current_picture.qscale_table[mb_xy]= 0;
5144 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
5145 // All coeffs are present
5146 memset(h->non_zero_count[mb_xy], 16, 16);
5148 s->current_picture.mb_type[mb_xy]= mb_type;
5153 h->ref_count[0] <<= 1;
5154 h->ref_count[1] <<= 1;
5157 fill_caches(h, mb_type, 0);
5160 if(IS_INTRA(mb_type)){
5161 // init_top_left_availability(h);
5162 if(IS_INTRA4x4(mb_type)){
5165 if(dct8x8_allowed && get_bits1(&s->gb)){
5166 mb_type |= MB_TYPE_8x8DCT;
5170 // fill_intra4x4_pred_table(h);
5171 for(i=0; i<16; i+=di){
5172 int mode= pred_intra_mode(h, i);
5174 if(!get_bits1(&s->gb)){
5175 const int rem_mode= get_bits(&s->gb, 3);
5176 mode = rem_mode + (rem_mode >= mode);
5180 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
5182 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
5184 write_back_intra_pred_mode(h);
5185 if( check_intra4x4_pred_mode(h) < 0)
5188 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
5189 if(h->intra16x16_pred_mode < 0)
5192 h->chroma_pred_mode= get_ue_golomb(&s->gb);
5194 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
5195 if(h->chroma_pred_mode < 0)
5197 }else if(partition_count==4){
5198 int i, j, sub_partition_count[4], list, ref[2][4];
5200 if(h->slice_type == B_TYPE){
5202 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
5203 if(h->sub_mb_type[i] >=13){
5204 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
5207 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
5208 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
5210 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
5211 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
5212 pred_direct_motion(h, &mb_type);
5213 h->ref_cache[0][scan8[4]] =
5214 h->ref_cache[1][scan8[4]] =
5215 h->ref_cache[0][scan8[12]] =
5216 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
5219 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
5221 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
5222 if(h->sub_mb_type[i] >=4){
5223 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
5226 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
5227 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
5231 for(list=0; list<2; list++){
5232 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
5233 if(ref_count == 0) continue;
5235 if(IS_DIRECT(h->sub_mb_type[i])) continue;
5236 if(IS_DIR(h->sub_mb_type[i], 0, list)){
5237 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
5246 dct8x8_allowed = get_dct8x8_allowed(h);
5248 for(list=0; list<2; list++){
5249 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
5250 if(ref_count == 0) continue;
5253 if(IS_DIRECT(h->sub_mb_type[i])) {
5254 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
5257 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
5258 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
5260 if(IS_DIR(h->sub_mb_type[i], 0, list)){
5261 const int sub_mb_type= h->sub_mb_type[i];
5262 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
5263 for(j=0; j<sub_partition_count[i]; j++){
5265 const int index= 4*i + block_width*j;
5266 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
5267 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
5268 mx += get_se_golomb(&s->gb);
5269 my += get_se_golomb(&s->gb);
5270 tprintf("final mv:%d %d\n", mx, my);
5272 if(IS_SUB_8X8(sub_mb_type)){
5273 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
5274 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
5275 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
5276 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
5277 }else if(IS_SUB_8X4(sub_mb_type)){
5278 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
5279 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
5280 }else if(IS_SUB_4X8(sub_mb_type)){
5281 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
5282 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
5284 assert(IS_SUB_4X4(sub_mb_type));
5285 mv_cache[ 0 ][0]= mx;
5286 mv_cache[ 0 ][1]= my;
5290 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
5296 }else if(IS_DIRECT(mb_type)){
5297 pred_direct_motion(h, &mb_type);
5298 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
5300 int list, mx, my, i;
5301 //FIXME we should set ref_idx_l? to 0 if we use that later ...
5302 if(IS_16X16(mb_type)){
5303 for(list=0; list<2; list++){
5304 if(h->ref_count[list]>0){
5305 if(IS_DIR(mb_type, 0, list)){
5306 const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
5307 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
5309 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1);
5312 for(list=0; list<2; list++){
5313 if(IS_DIR(mb_type, 0, list)){
5314 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
5315 mx += get_se_golomb(&s->gb);
5316 my += get_se_golomb(&s->gb);
5317 tprintf("final mv:%d %d\n", mx, my);
5319 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
5321 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
5324 else if(IS_16X8(mb_type)){
5325 for(list=0; list<2; list++){
5326 if(h->ref_count[list]>0){
5328 if(IS_DIR(mb_type, i, list)){
5329 const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
5330 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
5332 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
5336 for(list=0; list<2; list++){
5338 if(IS_DIR(mb_type, i, list)){
5339 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
5340 mx += get_se_golomb(&s->gb);
5341 my += get_se_golomb(&s->gb);
5342 tprintf("final mv:%d %d\n", mx, my);
5344 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
5346 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
5350 assert(IS_8X16(mb_type));
5351 for(list=0; list<2; list++){
5352 if(h->ref_count[list]>0){
5354 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
5355 const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
5356 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
5358 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
5362 for(list=0; list<2; list++){
5364 if(IS_DIR(mb_type, i, list)){
5365 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
5366 mx += get_se_golomb(&s->gb);
5367 my += get_se_golomb(&s->gb);
5368 tprintf("final mv:%d %d\n", mx, my);
5370 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
5372 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
5378 if(IS_INTER(mb_type))
5379 write_back_motion(h, mb_type);
5381 if(!IS_INTRA16x16(mb_type)){
5382 cbp= get_ue_golomb(&s->gb);
5384 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
5388 if(IS_INTRA4x4(mb_type))
5389 cbp= golomb_to_intra4x4_cbp[cbp];
5391 cbp= golomb_to_inter_cbp[cbp];
5395 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
5396 if(get_bits1(&s->gb))
5397 mb_type |= MB_TYPE_8x8DCT;
5399 s->current_picture.mb_type[mb_xy]= mb_type;
5401 if(cbp || IS_INTRA16x16(mb_type)){
5402 int i8x8, i4x4, chroma_idx;
5403 int chroma_qp, dquant;
5404 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
5405 const uint8_t *scan, *scan8x8, *dc_scan;
5407 // fill_non_zero_count_cache(h);
5409 if(IS_INTERLACED(mb_type)){
5410 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
5411 scan= s->qscale ? h->field_scan : h->field_scan_q0;
5412 dc_scan= luma_dc_field_scan;
5414 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
5415 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
5416 dc_scan= luma_dc_zigzag_scan;
5419 dquant= get_se_golomb(&s->gb);
5421 if( dquant > 25 || dquant < -26 ){
5422 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
5426 s->qscale += dquant;
5427 if(((unsigned)s->qscale) > 51){
5428 if(s->qscale<0) s->qscale+= 52;
5429 else s->qscale-= 52;
5432 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
5433 if(IS_INTRA16x16(mb_type)){
5434 if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
5435 return -1; //FIXME continue if partitioned and other return -1 too
5438 assert((cbp&15) == 0 || (cbp&15) == 15);
5441 for(i8x8=0; i8x8<4; i8x8++){
5442 for(i4x4=0; i4x4<4; i4x4++){
5443 const int index= i4x4 + 4*i8x8;
5444 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
5450 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
5453 for(i8x8=0; i8x8<4; i8x8++){
5454 if(cbp & (1<<i8x8)){
5455 if(IS_8x8DCT(mb_type)){
5456 DCTELEM *buf = &h->mb[64*i8x8];
5458 for(i4x4=0; i4x4<4; i4x4++){
5459 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
5460 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
5463 nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
5464 nnz[0] += nnz[1] + nnz[8] + nnz[9];
5466 for(i4x4=0; i4x4<4; i4x4++){
5467 const int index= i4x4 + 4*i8x8;
5469 if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
5475 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
5476 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
5482 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
5483 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
5489 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
5490 for(i4x4=0; i4x4<4; i4x4++){
5491 const int index= 16 + 4*chroma_idx + i4x4;
5492 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][chroma_qp], 15) < 0){
5498 uint8_t * const nnz= &h->non_zero_count_cache[0];
5499 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
5500 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
5503 uint8_t * const nnz= &h->non_zero_count_cache[0];
5504 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
5505 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
5506 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
5508 s->current_picture.qscale_table[mb_xy]= s->qscale;
5509 write_back_non_zero_count(h);
5512 h->ref_count[0] >>= 1;
5513 h->ref_count[1] >>= 1;
5519 static int decode_cabac_field_decoding_flag(H264Context *h) {
5520 MpegEncContext * const s = &h->s;
5521 const int mb_x = s->mb_x;
5522 const int mb_y = s->mb_y & ~1;
5523 const int mba_xy = mb_x - 1 + mb_y *s->mb_stride;
5524 const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride;
5526 unsigned int ctx = 0;
5528 if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
5531 if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
5535 return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );
5538 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
5539 uint8_t *state= &h->cabac_state[ctx_base];
5543 MpegEncContext * const s = &h->s;
5544 const int mba_xy = h->left_mb_xy[0];
5545 const int mbb_xy = h->top_mb_xy;
5547 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
5549 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
5551 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
5552 return 0; /* I4x4 */
5555 if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 )
5556 return 0; /* I4x4 */
5559 if( get_cabac_terminate( &h->cabac ) )
5560 return 25; /* PCM */
5562 mb_type = 1; /* I16x16 */
5563 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
5564 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
5565 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
5566 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
5567 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
5571 static int decode_cabac_mb_type( H264Context *h ) {
5572 MpegEncContext * const s = &h->s;
5574 if( h->slice_type == I_TYPE ) {
5575 return decode_cabac_intra_mb_type(h, 3, 1);
5576 } else if( h->slice_type == P_TYPE ) {
5577 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
5579 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
5580 /* P_L0_D16x16, P_8x8 */
5581 return 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
5583 /* P_L0_D8x16, P_L0_D16x8 */
5584 return 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
5587 return decode_cabac_intra_mb_type(h, 17, 0) + 5;
5589 } else if( h->slice_type == B_TYPE ) {
5590 const int mba_xy = h->left_mb_xy[0];
5591 const int mbb_xy = h->top_mb_xy;
5595 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
5597 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
5600 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
5601 return 0; /* B_Direct_16x16 */
5603 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
5604 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
5607 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
5608 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
5609 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
5610 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
5612 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
5613 else if( bits == 13 ) {
5614 return decode_cabac_intra_mb_type(h, 32, 0) + 23;
5615 } else if( bits == 14 )
5616 return 11; /* B_L1_L0_8x16 */
5617 else if( bits == 15 )
5618 return 22; /* B_8x8 */
5620 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
5621 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
5623 /* TODO SI/SP frames? */
5628 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
5629 MpegEncContext * const s = &h->s;
5633 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
5634 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
5637 && h->slice_table[mba_xy] == h->slice_num
5638 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
5639 mba_xy += s->mb_stride;
5641 mbb_xy = mb_xy - s->mb_stride;
5643 && h->slice_table[mbb_xy] == h->slice_num
5644 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
5645 mbb_xy -= s->mb_stride;
5647 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
5649 int mb_xy = mb_x + mb_y*s->mb_stride;
5651 mbb_xy = mb_xy - s->mb_stride;
5654 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
5656 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
5659 if( h->slice_type == B_TYPE )
5661 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
5664 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
5667 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
5670 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
5671 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
5672 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
5674 if( mode >= pred_mode )
5680 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
5681 const int mba_xy = h->left_mb_xy[0];
5682 const int mbb_xy = h->top_mb_xy;
5686 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
5687 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
5690 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
5693 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
5696 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
5698 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
5704 static const uint8_t block_idx_x[16] = {
5705 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
5707 static const uint8_t block_idx_y[16] = {
5708 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
5710 static const uint8_t block_idx_xy[4][4] = {
5717 static int decode_cabac_mb_cbp_luma( H264Context *h) {
5722 if( h->slice_table[h->top_mb_xy] == h->slice_num ) {
5724 tprintf("cbp_b = top_cbp = %x\n", cbp_b);
5727 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
5732 x = block_idx_x[4*i8x8];
5733 y = block_idx_y[4*i8x8];
5737 else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) {
5738 cbp_a = h->left_cbp;
5739 tprintf("cbp_a = left_cbp = %x\n", cbp_a);
5745 /* No need to test for skip as we put 0 for skip block */
5746 /* No need to test for IPCM as we put 1 for IPCM block */
5748 int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
5749 if( ((cbp_a >> i8x8a)&0x01) == 0 )
5754 int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
5755 if( ((cbp_b >> i8x8b)&0x01) == 0 )
5759 if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) {
5765 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
5769 cbp_a = (h->left_cbp>>4)&0x03;
5770 cbp_b = (h-> top_cbp>>4)&0x03;
5773 if( cbp_a > 0 ) ctx++;
5774 if( cbp_b > 0 ) ctx += 2;
5775 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
5779 if( cbp_a == 2 ) ctx++;
5780 if( cbp_b == 2 ) ctx += 2;
5781 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
5783 static int decode_cabac_mb_dqp( H264Context *h) {
5784 MpegEncContext * const s = &h->s;
5790 mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1;
5792 mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride;
5794 if( h->last_qscale_diff != 0 )
5797 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
5803 if(val > 102) //prevent infinite loop
5810 return -(val + 1)/2;
5812 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
5813 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
5815 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
5817 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
5821 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
5823 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
5824 return 0; /* B_Direct_8x8 */
5825 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
5826 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
5828 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
5829 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
5830 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
5833 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
5834 type += get_cabac( &h->cabac, &h->cabac_state[39] );
5838 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
5839 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
5842 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
5843 int refa = h->ref_cache[list][scan8[n] - 1];
5844 int refb = h->ref_cache[list][scan8[n] - 8];
5848 if( h->slice_type == B_TYPE) {
5849 if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
5851 if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
5860 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
5870 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
5871 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
5872 abs( h->mvd_cache[list][scan8[n] - 8][l] );
5873 int ctxbase = (l == 0) ? 40 : 47;
5878 else if( amvd > 32 )
5883 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
5888 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
5896 while( get_cabac_bypass( &h->cabac ) ) {
5901 if( get_cabac_bypass( &h->cabac ) )
5905 return get_cabac_bypass_sign( &h->cabac, -mvd );
5908 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) {
5913 nza = h->left_cbp&0x100;
5914 nzb = h-> top_cbp&0x100;
5915 } else if( cat == 1 || cat == 2 ) {
5916 nza = h->non_zero_count_cache[scan8[idx] - 1];
5917 nzb = h->non_zero_count_cache[scan8[idx] - 8];
5918 } else if( cat == 3 ) {
5919 nza = (h->left_cbp>>(6+idx))&0x01;
5920 nzb = (h-> top_cbp>>(6+idx))&0x01;
5923 nza = h->non_zero_count_cache[scan8[16+idx] - 1];
5924 nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
5933 return ctx + 4 * cat;
5936 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = {
5937 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5938 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
5939 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
5940 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
5943 static int decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff) {
5944 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride;
5945 static const int significant_coeff_flag_offset[2][6] = {
5946 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
5947 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
5949 static const int last_coeff_flag_offset[2][6] = {
5950 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
5951 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
5953 static const int coeff_abs_level_m1_offset[6] = {
5954 227+0, 227+10, 227+20, 227+30, 227+39, 426
5956 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
5957 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
5958 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
5959 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
5960 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
5961 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
5962 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
5963 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
5964 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
5970 int coeff_count = 0;
5973 int abslevelgt1 = 0;
5975 uint8_t *significant_coeff_ctx_base;
5976 uint8_t *last_coeff_ctx_base;
5977 uint8_t *abs_level_m1_ctx_base;
5980 #define CABAC_ON_STACK
5982 #ifdef CABAC_ON_STACK
5985 cc.range = h->cabac.range;
5986 cc.low = h->cabac.low;
5987 cc.bytestream= h->cabac.bytestream;
5989 #define CC &h->cabac
5993 /* cat: 0-> DC 16x16 n = 0
5994 * 1-> AC 16x16 n = luma4x4idx
5995 * 2-> Luma4x4 n = luma4x4idx
5996 * 3-> DC Chroma n = iCbCr
5997 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
5998 * 5-> Luma8x8 n = 4 * luma8x8idx
6001 /* read coded block flag */
6003 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) {
6004 if( cat == 1 || cat == 2 )
6005 h->non_zero_count_cache[scan8[n]] = 0;
6007 h->non_zero_count_cache[scan8[16+n]] = 0;
6008 #ifdef CABAC_ON_STACK
6009 h->cabac.range = cc.range ;
6010 h->cabac.low = cc.low ;
6011 h->cabac.bytestream= cc.bytestream;
6017 significant_coeff_ctx_base = h->cabac_state
6018 + significant_coeff_flag_offset[MB_FIELD][cat];
6019 last_coeff_ctx_base = h->cabac_state
6020 + last_coeff_flag_offset[MB_FIELD][cat];
6021 abs_level_m1_ctx_base = h->cabac_state
6022 + coeff_abs_level_m1_offset[cat];
6025 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
6026 for(last= 0; last < coefs; last++) { \
6027 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
6028 if( get_cabac( CC, sig_ctx )) { \
6029 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
6030 index[coeff_count++] = last; \
6031 if( get_cabac( CC, last_ctx ) ) { \
6037 if( last == max_coeff -1 ) {\
6038 index[coeff_count++] = last;\
6040 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
6041 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
6042 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
6044 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
6046 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
6048 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
6051 assert(coeff_count > 0);
6054 h->cbp_table[mb_xy] |= 0x100;
6055 else if( cat == 1 || cat == 2 )
6056 h->non_zero_count_cache[scan8[n]] = coeff_count;
6058 h->cbp_table[mb_xy] |= 0x40 << n;
6060 h->non_zero_count_cache[scan8[16+n]] = coeff_count;
6063 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
6066 for( coeff_count--; coeff_count >= 0; coeff_count-- ) {
6067 uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base;
6068 int j= scantable[index[coeff_count]];
6070 if( get_cabac( CC, ctx ) == 0 ) {
6072 block[j] = get_cabac_bypass_sign( CC, -1);
6074 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;;
6080 ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base;
6081 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
6085 if( coeff_abs >= 15 ) {
6087 while( get_cabac_bypass( CC ) ) {
6093 coeff_abs += coeff_abs + get_cabac_bypass( CC );
6099 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs;
6100 else block[j] = coeff_abs;
6102 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6;
6103 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6;
6109 #ifdef CABAC_ON_STACK
6110 h->cabac.range = cc.range ;
6111 h->cabac.low = cc.low ;
6112 h->cabac.bytestream= cc.bytestream;
6117 static void inline compute_mb_neighbors(H264Context *h)
6119 MpegEncContext * const s = &h->s;
6120 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
6121 h->top_mb_xy = mb_xy - s->mb_stride;
6122 h->left_mb_xy[0] = mb_xy - 1;
6124 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
6125 const int top_pair_xy = pair_xy - s->mb_stride;
6126 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
6127 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
6128 const int curr_mb_frame_flag = !MB_FIELD;
6129 const int bottom = (s->mb_y & 1);
6131 ? !curr_mb_frame_flag // bottom macroblock
6132 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
6134 h->top_mb_xy -= s->mb_stride;
6136 if (left_mb_frame_flag != curr_mb_frame_flag) {
6137 h->left_mb_xy[0] = pair_xy - 1;
6144 * decodes a macroblock
6145 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
6147 static int decode_mb_cabac(H264Context *h) {
6148 MpegEncContext * const s = &h->s;
6149 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
6150 int mb_type, partition_count, cbp = 0;
6151 int dct8x8_allowed= h->pps.transform_8x8_mode;
6153 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
6155 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
6156 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) {
6158 /* a skipped mb needs the aff flag from the following mb */
6159 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
6160 predict_field_decoding_flag(h);
6161 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
6162 skip = h->next_mb_skipped;
6164 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
6165 /* read skip flags */
6167 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
6168 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
6169 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
6170 if(h->next_mb_skipped)
6171 predict_field_decoding_flag(h);
6173 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
6178 h->cbp_table[mb_xy] = 0;
6179 h->chroma_pred_mode_table[mb_xy] = 0;
6180 h->last_qscale_diff = 0;
6187 if( (s->mb_y&1) == 0 )
6189 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
6191 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
6193 h->prev_mb_skipped = 0;
6195 compute_mb_neighbors(h);
6196 if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {
6197 av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );
6201 if( h->slice_type == B_TYPE ) {
6203 partition_count= b_mb_type_info[mb_type].partition_count;
6204 mb_type= b_mb_type_info[mb_type].type;
6207 goto decode_intra_mb;
6209 } else if( h->slice_type == P_TYPE ) {
6211 partition_count= p_mb_type_info[mb_type].partition_count;
6212 mb_type= p_mb_type_info[mb_type].type;
6215 goto decode_intra_mb;
6218 assert(h->slice_type == I_TYPE);
6220 partition_count = 0;
6221 cbp= i_mb_type_info[mb_type].cbp;
6222 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
6223 mb_type= i_mb_type_info[mb_type].type;
6226 mb_type |= MB_TYPE_INTERLACED;
6228 h->slice_table[ mb_xy ]= h->slice_num;
6230 if(IS_INTRA_PCM(mb_type)) {
6234 // We assume these blocks are very rare so we dont optimize it.
6235 // FIXME The two following lines get the bitstream position in the cabac
6236 // decode, I think it should be done by a function in cabac.h (or cabac.c).
6237 ptr= h->cabac.bytestream;
6238 if(h->cabac.low&0x1) ptr--;
6240 if(h->cabac.low&0x1FF) ptr--;
6243 // The pixels are stored in the same order as levels in h->mb array.
6244 for(y=0; y<16; y++){
6245 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
6246 for(x=0; x<16; x++){
6247 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr);
6248 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++;
6252 const int index= 256 + 4*(y&3) + 32*(y>>2);
6254 tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr);
6255 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
6259 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
6261 tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr);
6262 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
6266 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
6268 // All blocks are present
6269 h->cbp_table[mb_xy] = 0x1ef;
6270 h->chroma_pred_mode_table[mb_xy] = 0;
6271 // In deblocking, the quantizer is 0
6272 s->current_picture.qscale_table[mb_xy]= 0;
6273 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
6274 // All coeffs are present
6275 memset(h->non_zero_count[mb_xy], 16, 16);
6276 s->current_picture.mb_type[mb_xy]= mb_type;
6281 h->ref_count[0] <<= 1;
6282 h->ref_count[1] <<= 1;
6285 fill_caches(h, mb_type, 0);
6287 if( IS_INTRA( mb_type ) ) {
6289 if( IS_INTRA4x4( mb_type ) ) {
6290 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
6291 mb_type |= MB_TYPE_8x8DCT;
6292 for( i = 0; i < 16; i+=4 ) {
6293 int pred = pred_intra_mode( h, i );
6294 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
6295 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
6298 for( i = 0; i < 16; i++ ) {
6299 int pred = pred_intra_mode( h, i );
6300 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
6302 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
6305 write_back_intra_pred_mode(h);
6306 if( check_intra4x4_pred_mode(h) < 0 ) return -1;
6308 h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );
6309 if( h->intra16x16_pred_mode < 0 ) return -1;
6311 h->chroma_pred_mode_table[mb_xy] =
6312 h->chroma_pred_mode = decode_cabac_mb_chroma_pre_mode( h );
6314 h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode );
6315 if( h->chroma_pred_mode < 0 ) return -1;
6316 } else if( partition_count == 4 ) {
6317 int i, j, sub_partition_count[4], list, ref[2][4];
6319 if( h->slice_type == B_TYPE ) {
6320 for( i = 0; i < 4; i++ ) {
6321 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
6322 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
6323 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
6325 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
6326 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
6327 pred_direct_motion(h, &mb_type);
6328 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
6329 for( i = 0; i < 4; i++ )
6330 if( IS_DIRECT(h->sub_mb_type[i]) )
6331 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
6335 for( i = 0; i < 4; i++ ) {
6336 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
6337 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
6338 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
6342 for( list = 0; list < 2; list++ ) {
6343 if( h->ref_count[list] > 0 ) {
6344 for( i = 0; i < 4; i++ ) {
6345 if(IS_DIRECT(h->sub_mb_type[i])) continue;
6346 if(IS_DIR(h->sub_mb_type[i], 0, list)){
6347 if( h->ref_count[list] > 1 )
6348 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
6354 h->ref_cache[list][ scan8[4*i]+1 ]=
6355 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
6361 dct8x8_allowed = get_dct8x8_allowed(h);
6363 for(list=0; list<2; list++){
6365 if(IS_DIRECT(h->sub_mb_type[i])){
6366 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
6369 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
6371 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
6372 const int sub_mb_type= h->sub_mb_type[i];
6373 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
6374 for(j=0; j<sub_partition_count[i]; j++){
6377 const int index= 4*i + block_width*j;
6378 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
6379 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
6380 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
6382 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
6383 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
6384 tprintf("final mv:%d %d\n", mx, my);
6386 if(IS_SUB_8X8(sub_mb_type)){
6387 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
6388 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
6389 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
6390 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
6392 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]=
6393 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
6394 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]=
6395 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
6396 }else if(IS_SUB_8X4(sub_mb_type)){
6397 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
6398 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
6400 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx;
6401 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy;
6402 }else if(IS_SUB_4X8(sub_mb_type)){
6403 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
6404 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
6406 mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx;
6407 mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy;
6409 assert(IS_SUB_4X4(sub_mb_type));
6410 mv_cache[ 0 ][0]= mx;
6411 mv_cache[ 0 ][1]= my;
6413 mvd_cache[ 0 ][0]= mx - mpx;
6414 mvd_cache[ 0 ][1]= my - mpy;
6418 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
6419 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
6420 p[0] = p[1] = p[8] = p[9] = 0;
6421 pd[0]= pd[1]= pd[8]= pd[9]= 0;
6425 } else if( IS_DIRECT(mb_type) ) {
6426 pred_direct_motion(h, &mb_type);
6427 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
6428 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
6429 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
6431 int list, mx, my, i, mpx, mpy;
6432 if(IS_16X16(mb_type)){
6433 for(list=0; list<2; list++){
6434 if(IS_DIR(mb_type, 0, list)){
6435 if(h->ref_count[list] > 0 ){
6436 const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
6437 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
6440 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
6442 for(list=0; list<2; list++){
6443 if(IS_DIR(mb_type, 0, list)){
6444 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
6446 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
6447 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
6448 tprintf("final mv:%d %d\n", mx, my);
6450 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
6451 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
6453 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
6456 else if(IS_16X8(mb_type)){
6457 for(list=0; list<2; list++){
6458 if(h->ref_count[list]>0){
6460 if(IS_DIR(mb_type, i, list)){
6461 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
6462 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
6464 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
6468 for(list=0; list<2; list++){
6470 if(IS_DIR(mb_type, i, list)){
6471 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
6472 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
6473 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
6474 tprintf("final mv:%d %d\n", mx, my);
6476 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
6477 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
6479 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
6480 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
6485 assert(IS_8X16(mb_type));
6486 for(list=0; list<2; list++){
6487 if(h->ref_count[list]>0){
6489 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
6490 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
6491 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
6493 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
6497 for(list=0; list<2; list++){
6499 if(IS_DIR(mb_type, i, list)){
6500 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
6501 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
6502 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
6504 tprintf("final mv:%d %d\n", mx, my);
6505 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
6506 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
6508 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
6509 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
6516 if( IS_INTER( mb_type ) ) {
6517 h->chroma_pred_mode_table[mb_xy] = 0;
6518 write_back_motion( h, mb_type );
6521 if( !IS_INTRA16x16( mb_type ) ) {
6522 cbp = decode_cabac_mb_cbp_luma( h );
6523 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
6526 h->cbp_table[mb_xy] = h->cbp = cbp;
6528 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
6529 if( decode_cabac_mb_transform_size( h ) )
6530 mb_type |= MB_TYPE_8x8DCT;
6532 s->current_picture.mb_type[mb_xy]= mb_type;
6534 if( cbp || IS_INTRA16x16( mb_type ) ) {
6535 const uint8_t *scan, *scan8x8, *dc_scan;
6538 if(IS_INTERLACED(mb_type)){
6539 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
6540 scan= s->qscale ? h->field_scan : h->field_scan_q0;
6541 dc_scan= luma_dc_field_scan;
6543 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
6544 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
6545 dc_scan= luma_dc_zigzag_scan;
6548 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
6549 if( dqp == INT_MIN ){
6550 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
6554 if(((unsigned)s->qscale) > 51){
6555 if(s->qscale<0) s->qscale+= 52;
6556 else s->qscale-= 52;
6558 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
6560 if( IS_INTRA16x16( mb_type ) ) {
6562 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
6563 if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 0)
6566 for( i = 0; i < 16; i++ ) {
6567 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
6568 if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 )
6572 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
6576 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
6577 if( cbp & (1<<i8x8) ) {
6578 if( IS_8x8DCT(mb_type) ) {
6579 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
6580 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 )
6583 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
6584 const int index = 4*i8x8 + i4x4;
6585 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
6587 if( decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) < 0 )
6589 //STOP_TIMER("decode_residual")
6592 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
6593 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
6600 for( c = 0; c < 2; c++ ) {
6601 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
6602 if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 0)
6609 for( c = 0; c < 2; c++ ) {
6610 for( i = 0; i < 4; i++ ) {
6611 const int index = 16 + 4 * c + i;
6612 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
6613 if( decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp], 15) < 0)
6618 uint8_t * const nnz= &h->non_zero_count_cache[0];
6619 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
6620 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
6623 uint8_t * const nnz= &h->non_zero_count_cache[0];
6624 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
6625 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
6626 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
6627 h->last_qscale_diff = 0;
6630 s->current_picture.qscale_table[mb_xy]= s->qscale;
6631 write_back_non_zero_count(h);
6634 h->ref_count[0] >>= 1;
6635 h->ref_count[1] >>= 1;
6642 static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6644 const int index_a = qp + h->slice_alpha_c0_offset;
6645 const int alpha = (alpha_table+52)[index_a];
6646 const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6651 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
6652 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
6654 /* 16px edge length, because bS=4 is triggered by being at
6655 * the edge of an intra MB, so all 4 bS are the same */
6656 for( d = 0; d < 16; d++ ) {
6657 const int p0 = pix[-1];
6658 const int p1 = pix[-2];
6659 const int p2 = pix[-3];
6661 const int q0 = pix[0];
6662 const int q1 = pix[1];
6663 const int q2 = pix[2];
6665 if( FFABS( p0 - q0 ) < alpha &&
6666 FFABS( p1 - p0 ) < beta &&
6667 FFABS( q1 - q0 ) < beta ) {
6669 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6670 if( FFABS( p2 - p0 ) < beta)
6672 const int p3 = pix[-4];
6674 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6675 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6676 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6679 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6681 if( FFABS( q2 - q0 ) < beta)
6683 const int q3 = pix[3];
6685 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6686 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6687 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6690 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6694 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6695 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6697 tprintf("filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]);
6703 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6705 const int index_a = qp + h->slice_alpha_c0_offset;
6706 const int alpha = (alpha_table+52)[index_a];
6707 const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6712 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
6713 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
6715 h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
6719 static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
6721 for( i = 0; i < 16; i++, pix += stride) {
6727 int bS_index = (i >> 1);
6730 bS_index |= (i & 1);
6733 if( bS[bS_index] == 0 ) {
6737 qp_index = MB_FIELD ? (i >> 3) : (i & 1);
6738 index_a = qp[qp_index] + h->slice_alpha_c0_offset;
6739 alpha = (alpha_table+52)[index_a];
6740 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
6742 if( bS[bS_index] < 4 ) {
6743 const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1];
6744 const int p0 = pix[-1];
6745 const int p1 = pix[-2];
6746 const int p2 = pix[-3];
6747 const int q0 = pix[0];
6748 const int q1 = pix[1];
6749 const int q2 = pix[2];
6751 if( FFABS( p0 - q0 ) < alpha &&
6752 FFABS( p1 - p0 ) < beta &&
6753 FFABS( q1 - q0 ) < beta ) {
6757 if( FFABS( p2 - p0 ) < beta ) {
6758 pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
6761 if( FFABS( q2 - q0 ) < beta ) {
6762 pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
6766 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
6767 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
6768 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
6769 tprintf("filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
6772 const int p0 = pix[-1];
6773 const int p1 = pix[-2];
6774 const int p2 = pix[-3];
6776 const int q0 = pix[0];
6777 const int q1 = pix[1];
6778 const int q2 = pix[2];
6780 if( FFABS( p0 - q0 ) < alpha &&
6781 FFABS( p1 - p0 ) < beta &&
6782 FFABS( q1 - q0 ) < beta ) {
6784 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6785 if( FFABS( p2 - p0 ) < beta)
6787 const int p3 = pix[-4];
6789 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6790 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6791 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6794 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6796 if( FFABS( q2 - q0 ) < beta)
6798 const int q3 = pix[3];
6800 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6801 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6802 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6805 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6809 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6810 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6812 tprintf("filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
6817 static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
6819 for( i = 0; i < 8; i++, pix += stride) {
6827 if( bS[bS_index] == 0 ) {
6831 qp_index = MB_FIELD ? (i >> 2) : (i & 1);
6832 index_a = qp[qp_index] + h->slice_alpha_c0_offset;
6833 alpha = (alpha_table+52)[index_a];
6834 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
6836 if( bS[bS_index] < 4 ) {
6837 const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1;
6838 const int p0 = pix[-1];
6839 const int p1 = pix[-2];
6840 const int q0 = pix[0];
6841 const int q1 = pix[1];
6843 if( FFABS( p0 - q0 ) < alpha &&
6844 FFABS( p1 - p0 ) < beta &&
6845 FFABS( q1 - q0 ) < beta ) {
6846 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
6848 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
6849 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
6850 tprintf("filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
6853 const int p0 = pix[-1];
6854 const int p1 = pix[-2];
6855 const int q0 = pix[0];
6856 const int q1 = pix[1];
6858 if( FFABS( p0 - q0 ) < alpha &&
6859 FFABS( p1 - p0 ) < beta &&
6860 FFABS( q1 - q0 ) < beta ) {
6862 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
6863 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
6864 tprintf("filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
6870 static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6872 const int index_a = qp + h->slice_alpha_c0_offset;
6873 const int alpha = (alpha_table+52)[index_a];
6874 const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6875 const int pix_next = stride;
6880 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
6881 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
6883 /* 16px edge length, see filter_mb_edgev */
6884 for( d = 0; d < 16; d++ ) {
6885 const int p0 = pix[-1*pix_next];
6886 const int p1 = pix[-2*pix_next];
6887 const int p2 = pix[-3*pix_next];
6888 const int q0 = pix[0];
6889 const int q1 = pix[1*pix_next];
6890 const int q2 = pix[2*pix_next];
6892 if( FFABS( p0 - q0 ) < alpha &&
6893 FFABS( p1 - p0 ) < beta &&
6894 FFABS( q1 - q0 ) < beta ) {
6896 const int p3 = pix[-4*pix_next];
6897 const int q3 = pix[ 3*pix_next];
6899 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6900 if( FFABS( p2 - p0 ) < beta) {
6902 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6903 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6904 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6907 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6909 if( FFABS( q2 - q0 ) < beta) {
6911 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6912 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6913 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6916 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6920 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6921 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6923 tprintf("filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]);
6930 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6932 const int index_a = qp + h->slice_alpha_c0_offset;
6933 const int alpha = (alpha_table+52)[index_a];
6934 const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6939 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
6940 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
6942 h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
6946 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) {
6947 MpegEncContext * const s = &h->s;
6949 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;
6951 if(mb_x==0 || mb_y==0 || !s->dsp.h264_loop_filter_strength) {
6952 filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
6955 assert(!FRAME_MBAFF);
6957 mb_xy = mb_x + mb_y*s->mb_stride;
6958 mb_type = s->current_picture.mb_type[mb_xy];
6959 qp = s->current_picture.qscale_table[mb_xy];
6960 qp0 = s->current_picture.qscale_table[mb_xy-1];
6961 qp1 = s->current_picture.qscale_table[h->top_mb_xy];
6962 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp );
6963 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 );
6964 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 );
6965 qp0 = (qp + qp0 + 1) >> 1;
6966 qp1 = (qp + qp1 + 1) >> 1;
6967 qpc0 = (qpc + qpc0 + 1) >> 1;
6968 qpc1 = (qpc + qpc1 + 1) >> 1;
6969 qp_thresh = 15 - h->slice_alpha_c0_offset;
6970 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh &&
6971 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh)
6974 if( IS_INTRA(mb_type) ) {
6975 int16_t bS4[4] = {4,4,4,4};
6976 int16_t bS3[4] = {3,3,3,3};
6977 if( IS_8x8DCT(mb_type) ) {
6978 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );
6979 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );
6980 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 );
6981 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );
6983 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );
6984 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp );
6985 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );
6986 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp );
6987 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 );
6988 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp );
6989 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );
6990 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp );
6992 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 );
6993 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc );
6994 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 );
6995 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc );
6996 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 );
6997 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc );
6998 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 );
6999 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc );
7002 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]);
7003 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS;
7005 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) {
7007 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL;
7009 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 :
7010 (mb_type & MB_TYPE_16x8) ? 1 : 0;
7011 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16))
7012 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16))
7014 int step = IS_8x8DCT(mb_type) ? 2 : 1;
7015 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4;
7016 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache,
7017 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 );
7019 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) )
7020 bSv[0][0] = 0x0004000400040004ULL;
7021 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) )
7022 bSv[1][0] = 0x0004000400040004ULL;
7024 #define FILTER(hv,dir,edge)\
7025 if(bSv[dir][edge]) {\
7026 filter_mb_edge##hv( h, &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir );\
7028 filter_mb_edgec##hv( h, &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\
7029 filter_mb_edgec##hv( h, &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\
7035 } else if( IS_8x8DCT(mb_type) ) {
7054 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) {
7055 MpegEncContext * const s = &h->s;
7056 const int mb_xy= mb_x + mb_y*s->mb_stride;
7057 const int mb_type = s->current_picture.mb_type[mb_xy];
7058 const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
7059 int first_vertical_edge_done = 0;
7061 /* FIXME: A given frame may occupy more than one position in
7062 * the reference list. So ref2frm should be populated with
7063 * frame numbers, not indices. */
7064 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
7065 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
7067 //for sufficiently low qp, filtering wouldn't do anything
7068 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
7070 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset);
7071 int qp = s->current_picture.qscale_table[mb_xy];
7073 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh)
7074 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){
7080 // left mb is in picture
7081 && h->slice_table[mb_xy-1] != 255
7082 // and current and left pair do not have the same interlaced type
7083 && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
7084 // and left mb is in the same slice if deblocking_filter == 2
7085 && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {
7086 /* First vertical edge is different in MBAFF frames
7087 * There are 8 different bS to compute and 2 different Qp
7089 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride;
7090 const int left_mb_xy[2] = { pair_xy-1, pair_xy-1+s->mb_stride };
7094 int mb_qp, mbn0_qp, mbn1_qp;
7096 first_vertical_edge_done = 1;
7098 if( IS_INTRA(mb_type) )
7099 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4;
7101 for( i = 0; i < 8; i++ ) {
7102 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1];
7104 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) )
7106 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 ||
7107 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */
7108 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] )
7115 mb_qp = s->current_picture.qscale_table[mb_xy];
7116 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]];
7117 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]];
7118 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
7119 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +
7120 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1;
7121 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
7122 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +
7123 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1;
7126 tprintf("filter mb:%d/%d MBAFF, QPy:%d/%d, QPc:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], chroma_qp[0], chroma_qp[1], linesize, uvlinesize);
7127 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
7128 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp );
7129 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp );
7130 filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp );
7132 /* dir : 0 -> vertical edge, 1 -> horizontal edge */
7133 for( dir = 0; dir < 2; dir++ )
7136 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
7137 const int mbm_type = s->current_picture.mb_type[mbm_xy];
7138 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0;
7140 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
7141 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
7142 // how often to recheck mv-based bS when iterating between edges
7143 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
7144 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
7145 // how often to recheck mv-based bS when iterating along each edge
7146 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
7148 if (first_vertical_edge_done) {
7150 first_vertical_edge_done = 0;
7153 if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
7156 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
7157 && !IS_INTERLACED(mb_type)
7158 && IS_INTERLACED(mbm_type)
7160 // This is a special case in the norm where the filtering must
7161 // be done twice (one each of the field) even if we are in a
7162 // frame macroblock.
7164 static const int nnz_idx[4] = {4,5,6,3};
7165 unsigned int tmp_linesize = 2 * linesize;
7166 unsigned int tmp_uvlinesize = 2 * uvlinesize;
7167 int mbn_xy = mb_xy - 2 * s->mb_stride;
7172 for(j=0; j<2; j++, mbn_xy += s->mb_stride){
7173 if( IS_INTRA(mb_type) ||
7174 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
7175 bS[0] = bS[1] = bS[2] = bS[3] = 3;
7177 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];
7178 for( i = 0; i < 4; i++ ) {
7179 if( h->non_zero_count_cache[scan8[0]+i] != 0 ||
7180 mbn_nnz[nnz_idx[i]] != 0 )
7186 // Do not use s->qscale as luma quantizer because it has not the same
7187 // value in IPCM macroblocks.
7188 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
7189 tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
7190 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
7191 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );
7192 chroma_qp = ( h->chroma_qp +
7193 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
7194 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );
7195 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );
7202 for( edge = start; edge < edges; edge++ ) {
7203 /* mbn_xy: neighbor macroblock */
7204 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
7205 const int mbn_type = s->current_picture.mb_type[mbn_xy];
7209 if( (edge&1) && IS_8x8DCT(mb_type) )
7212 if( IS_INTRA(mb_type) ||
7213 IS_INTRA(mbn_type) ) {
7216 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
7217 || ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
7226 bS[0] = bS[1] = bS[2] = bS[3] = value;
7231 if( edge & mask_edge ) {
7232 bS[0] = bS[1] = bS[2] = bS[3] = 0;
7235 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
7236 bS[0] = bS[1] = bS[2] = bS[3] = 1;
7239 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
7240 int b_idx= 8 + 4 + edge * (dir ? 8:1);
7241 int bn_idx= b_idx - (dir ? 8:1);
7243 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) {
7244 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
7245 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
7246 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
7248 bS[0] = bS[1] = bS[2] = bS[3] = v;
7254 for( i = 0; i < 4; i++ ) {
7255 int x = dir == 0 ? edge : i;
7256 int y = dir == 0 ? i : edge;
7257 int b_idx= 8 + 4 + x + 8*y;
7258 int bn_idx= b_idx - (dir ? 8:1);
7260 if( h->non_zero_count_cache[b_idx] != 0 ||
7261 h->non_zero_count_cache[bn_idx] != 0 ) {
7267 for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
7268 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
7269 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
7270 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
7278 if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
7283 // Do not use s->qscale as luma quantizer because it has not the same
7284 // value in IPCM macroblocks.
7285 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
7286 //tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]);
7287 tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
7288 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
7290 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
7291 if( (edge&1) == 0 ) {
7292 int chroma_qp = ( h->chroma_qp +
7293 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
7294 filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp );
7295 filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp );
7298 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
7299 if( (edge&1) == 0 ) {
7300 int chroma_qp = ( h->chroma_qp +
7301 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
7302 filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
7303 filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
7310 static int decode_slice(H264Context *h){
7311 MpegEncContext * const s = &h->s;
7312 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
7316 if( h->pps.cabac ) {
7320 align_get_bits( &s->gb );
7323 ff_init_cabac_states( &h->cabac);
7324 ff_init_cabac_decoder( &h->cabac,
7325 s->gb.buffer + get_bits_count(&s->gb)/8,
7326 ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
7327 /* calculate pre-state */
7328 for( i= 0; i < 460; i++ ) {
7330 if( h->slice_type == I_TYPE )
7331 pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
7333 pre = clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
7336 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
7338 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
7343 int ret = decode_mb_cabac(h);
7345 //STOP_TIMER("decode_mb_cabac")
7347 if(ret>=0) hl_decode_mb(h);
7349 if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
7352 if(ret>=0) ret = decode_mb_cabac(h);
7354 if(ret>=0) hl_decode_mb(h);
7357 eos = get_cabac_terminate( &h->cabac );
7359 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
7360 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%d)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream);
7361 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
7365 if( ++s->mb_x >= s->mb_width ) {
7367 ff_draw_horiz_band(s, 16*s->mb_y, 16);
7374 if( eos || s->mb_y >= s->mb_height ) {
7375 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
7376 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7383 int ret = decode_mb_cavlc(h);
7385 if(ret>=0) hl_decode_mb(h);
7387 if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
7389 ret = decode_mb_cavlc(h);
7391 if(ret>=0) hl_decode_mb(h);
7396 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
7397 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
7402 if(++s->mb_x >= s->mb_width){
7404 ff_draw_horiz_band(s, 16*s->mb_y, 16);
7409 if(s->mb_y >= s->mb_height){
7410 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
7412 if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
7413 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7417 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7424 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
7425 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
7426 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
7427 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7431 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
7440 for(;s->mb_y < s->mb_height; s->mb_y++){
7441 for(;s->mb_x < s->mb_width; s->mb_x++){
7442 int ret= decode_mb(h);
7447 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
7448 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
7453 if(++s->mb_x >= s->mb_width){
7455 if(++s->mb_y >= s->mb_height){
7456 if(get_bits_count(s->gb) == s->gb.size_in_bits){
7457 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7461 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7468 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
7469 if(get_bits_count(s->gb) == s->gb.size_in_bits){
7470 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
7474 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
7481 ff_draw_horiz_band(s, 16*s->mb_y, 16);
7484 return -1; //not reached
7487 static int decode_unregistered_user_data(H264Context *h, int size){
7488 MpegEncContext * const s = &h->s;
7489 uint8_t user_data[16+256];
7495 for(i=0; i<sizeof(user_data)-1 && i<size; i++){
7496 user_data[i]= get_bits(&s->gb, 8);
7500 e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
7501 if(e==1 && build>=0)
7502 h->x264_build= build;
7504 if(s->avctx->debug & FF_DEBUG_BUGS)
7505 av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);
7508 skip_bits(&s->gb, 8);
7513 static int decode_sei(H264Context *h){
7514 MpegEncContext * const s = &h->s;
7516 while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
7521 type+= show_bits(&s->gb, 8);
7522 }while(get_bits(&s->gb, 8) == 255);
7526 size+= show_bits(&s->gb, 8);
7527 }while(get_bits(&s->gb, 8) == 255);
7531 if(decode_unregistered_user_data(h, size) < 0)
7535 skip_bits(&s->gb, 8*size);
7538 //FIXME check bits here
7539 align_get_bits(&s->gb);
7545 static inline void decode_hrd_parameters(H264Context *h, SPS *sps){
7546 MpegEncContext * const s = &h->s;
7548 cpb_count = get_ue_golomb(&s->gb) + 1;
7549 get_bits(&s->gb, 4); /* bit_rate_scale */
7550 get_bits(&s->gb, 4); /* cpb_size_scale */
7551 for(i=0; i<cpb_count; i++){
7552 get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
7553 get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
7554 get_bits1(&s->gb); /* cbr_flag */
7556 get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */
7557 get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */
7558 get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */
7559 get_bits(&s->gb, 5); /* time_offset_length */
7562 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
7563 MpegEncContext * const s = &h->s;
7564 int aspect_ratio_info_present_flag, aspect_ratio_idc;
7565 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;
7567 aspect_ratio_info_present_flag= get_bits1(&s->gb);
7569 if( aspect_ratio_info_present_flag ) {
7570 aspect_ratio_idc= get_bits(&s->gb, 8);
7571 if( aspect_ratio_idc == EXTENDED_SAR ) {
7572 sps->sar.num= get_bits(&s->gb, 16);
7573 sps->sar.den= get_bits(&s->gb, 16);
7574 }else if(aspect_ratio_idc < 14){
7575 sps->sar= pixel_aspect[aspect_ratio_idc];
7577 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
7584 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
7586 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
7587 get_bits1(&s->gb); /* overscan_appropriate_flag */
7590 if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */
7591 get_bits(&s->gb, 3); /* video_format */
7592 get_bits1(&s->gb); /* video_full_range_flag */
7593 if(get_bits1(&s->gb)){ /* colour_description_present_flag */
7594 get_bits(&s->gb, 8); /* colour_primaries */
7595 get_bits(&s->gb, 8); /* transfer_characteristics */
7596 get_bits(&s->gb, 8); /* matrix_coefficients */
7600 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
7601 get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */
7602 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
7605 sps->timing_info_present_flag = get_bits1(&s->gb);
7606 if(sps->timing_info_present_flag){
7607 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
7608 sps->time_scale = get_bits_long(&s->gb, 32);
7609 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
7612 nal_hrd_parameters_present_flag = get_bits1(&s->gb);
7613 if(nal_hrd_parameters_present_flag)
7614 decode_hrd_parameters(h, sps);
7615 vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
7616 if(vcl_hrd_parameters_present_flag)
7617 decode_hrd_parameters(h, sps);
7618 if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
7619 get_bits1(&s->gb); /* low_delay_hrd_flag */
7620 get_bits1(&s->gb); /* pic_struct_present_flag */
7622 sps->bitstream_restriction_flag = get_bits1(&s->gb);
7623 if(sps->bitstream_restriction_flag){
7624 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
7625 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
7626 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
7627 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
7628 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
7629 sps->num_reorder_frames = get_ue_golomb(&s->gb);
7630 get_ue_golomb(&s->gb); /* max_dec_frame_buffering */
7636 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
7637 const uint8_t *jvt_list, const uint8_t *fallback_list){
7638 MpegEncContext * const s = &h->s;
7639 int i, last = 8, next = 8;
7640 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
7641 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
7642 memcpy(factors, fallback_list, size*sizeof(uint8_t));
7644 for(i=0;i<size;i++){
7646 next = (last + get_se_golomb(&s->gb)) & 0xff;
7647 if(!i && !next){ /* matrix not written, we use the preset one */
7648 memcpy(factors, jvt_list, size*sizeof(uint8_t));
7651 last = factors[scan[i]] = next ? next : last;
7655 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
7656 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
7657 MpegEncContext * const s = &h->s;
7658 int fallback_sps = !is_sps && sps->scaling_matrix_present;
7659 const uint8_t *fallback[4] = {
7660 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
7661 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
7662 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
7663 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
7665 if(get_bits1(&s->gb)){
7666 sps->scaling_matrix_present |= is_sps;
7667 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
7668 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
7669 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
7670 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
7671 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
7672 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
7673 if(is_sps || pps->transform_8x8_mode){
7674 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
7675 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y
7677 } else if(fallback_sps) {
7678 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t));
7679 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t));
7683 static inline int decode_seq_parameter_set(H264Context *h){
7684 MpegEncContext * const s = &h->s;
7685 int profile_idc, level_idc;
7686 unsigned int sps_id;
7690 profile_idc= get_bits(&s->gb, 8);
7691 get_bits1(&s->gb); //constraint_set0_flag
7692 get_bits1(&s->gb); //constraint_set1_flag
7693 get_bits1(&s->gb); //constraint_set2_flag
7694 get_bits1(&s->gb); //constraint_set3_flag
7695 get_bits(&s->gb, 4); // reserved
7696 level_idc= get_bits(&s->gb, 8);
7697 sps_id= get_ue_golomb(&s->gb);
7699 if (sps_id >= MAX_SPS_COUNT){
7700 // ok it has gone out of hand, someone is sending us bad stuff.
7701 av_log(h->s.avctx, AV_LOG_ERROR, "illegal sps_id (%d)\n", sps_id);
7705 sps= &h->sps_buffer[ sps_id ];
7706 sps->profile_idc= profile_idc;
7707 sps->level_idc= level_idc;
7709 if(sps->profile_idc >= 100){ //high profile
7710 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc
7711 get_bits1(&s->gb); //residual_color_transform_flag
7712 get_ue_golomb(&s->gb); //bit_depth_luma_minus8
7713 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8
7714 sps->transform_bypass = get_bits1(&s->gb);
7715 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
7717 sps->scaling_matrix_present = 0;
7719 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
7720 sps->poc_type= get_ue_golomb(&s->gb);
7722 if(sps->poc_type == 0){ //FIXME #define
7723 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
7724 } else if(sps->poc_type == 1){//FIXME #define
7725 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
7726 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
7727 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
7728 sps->poc_cycle_length= get_ue_golomb(&s->gb);
7730 for(i=0; i<sps->poc_cycle_length; i++)
7731 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
7733 if(sps->poc_type > 2){
7734 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
7738 sps->ref_frame_count= get_ue_golomb(&s->gb);
7739 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){
7740 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
7742 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
7743 sps->mb_width= get_ue_golomb(&s->gb) + 1;
7744 sps->mb_height= get_ue_golomb(&s->gb) + 1;
7745 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
7746 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height))
7749 sps->frame_mbs_only_flag= get_bits1(&s->gb);
7750 if(!sps->frame_mbs_only_flag)
7751 sps->mb_aff= get_bits1(&s->gb);
7755 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
7757 #ifndef ALLOW_INTERLACE
7759 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
7761 if(!sps->direct_8x8_inference_flag && sps->mb_aff)
7762 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n");
7764 sps->crop= get_bits1(&s->gb);
7766 sps->crop_left = get_ue_golomb(&s->gb);
7767 sps->crop_right = get_ue_golomb(&s->gb);
7768 sps->crop_top = get_ue_golomb(&s->gb);
7769 sps->crop_bottom= get_ue_golomb(&s->gb);
7770 if(sps->crop_left || sps->crop_top){
7771 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
7777 sps->crop_bottom= 0;
7780 sps->vui_parameters_present_flag= get_bits1(&s->gb);
7781 if( sps->vui_parameters_present_flag )
7782 decode_vui_parameters(h, sps);
7784 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7785 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n",
7786 sps_id, sps->profile_idc, sps->level_idc,
7788 sps->ref_frame_count,
7789 sps->mb_width, sps->mb_height,
7790 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
7791 sps->direct_8x8_inference_flag ? "8B8" : "",
7792 sps->crop_left, sps->crop_right,
7793 sps->crop_top, sps->crop_bottom,
7794 sps->vui_parameters_present_flag ? "VUI" : ""
7800 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
7801 MpegEncContext * const s = &h->s;
7802 unsigned int pps_id= get_ue_golomb(&s->gb);
7805 if(pps_id>=MAX_PPS_COUNT){
7806 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
7809 pps = &h->pps_buffer[pps_id];
7811 pps->sps_id= get_ue_golomb(&s->gb);
7812 pps->cabac= get_bits1(&s->gb);
7813 pps->pic_order_present= get_bits1(&s->gb);
7814 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
7815 if(pps->slice_group_count > 1 ){
7816 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
7817 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
7818 switch(pps->mb_slice_group_map_type){
7821 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
7822 | run_length[ i ] |1 |ue(v) |
7827 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
7829 | top_left_mb[ i ] |1 |ue(v) |
7830 | bottom_right_mb[ i ] |1 |ue(v) |
7838 | slice_group_change_direction_flag |1 |u(1) |
7839 | slice_group_change_rate_minus1 |1 |ue(v) |
7844 | slice_group_id_cnt_minus1 |1 |ue(v) |
7845 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
7847 | slice_group_id[ i ] |1 |u(v) |
7852 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
7853 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
7854 if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){
7855 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
7859 pps->weighted_pred= get_bits1(&s->gb);
7860 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
7861 pps->init_qp= get_se_golomb(&s->gb) + 26;
7862 pps->init_qs= get_se_golomb(&s->gb) + 26;
7863 pps->chroma_qp_index_offset= get_se_golomb(&s->gb);
7864 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
7865 pps->constrained_intra_pred= get_bits1(&s->gb);
7866 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
7868 pps->transform_8x8_mode= 0;
7869 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
7870 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t));
7871 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t));
7873 if(get_bits_count(&s->gb) < bit_length){
7874 pps->transform_8x8_mode= get_bits1(&s->gb);
7875 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
7876 get_se_golomb(&s->gb); //second_chroma_qp_index_offset
7879 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7880 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n",
7881 pps_id, pps->sps_id,
7882 pps->cabac ? "CABAC" : "CAVLC",
7883 pps->slice_group_count,
7884 pps->ref_count[0], pps->ref_count[1],
7885 pps->weighted_pred ? "weighted" : "",
7886 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset,
7887 pps->deblocking_filter_parameters_present ? "LPAR" : "",
7888 pps->constrained_intra_pred ? "CONSTR" : "",
7889 pps->redundant_pic_cnt_present ? "REDU" : "",
7890 pps->transform_8x8_mode ? "8x8DCT" : ""
7898 * finds the end of the current frame in the bitstream.
7899 * @return the position of the first byte of the next frame, or -1
7901 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){
7904 ParseContext *pc = &(h->s.parse_context);
7905 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
7906 // mb_addr= pc->mb_addr - 1;
7908 for(i=0; i<=buf_size; i++){
7909 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
7910 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i);
7911 if(pc->frame_start_found){
7912 // If there isn't one more byte in the buffer
7913 // the test on first_mb_in_slice cannot be done yet
7914 // do it at next call.
7915 if (i >= buf_size) break;
7916 if (buf[i] & 0x80) {
7917 // first_mb_in_slice is 0, probably the first nal of a new
7919 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i);
7921 pc->frame_start_found= 0;
7925 pc->frame_start_found = 1;
7927 if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){
7928 if(pc->frame_start_found){
7930 pc->frame_start_found= 0;
7935 state= (state<<8) | buf[i];
7939 return END_NOT_FOUND;
7942 #ifdef CONFIG_H264_PARSER
7943 static int h264_parse(AVCodecParserContext *s,
7944 AVCodecContext *avctx,
7945 uint8_t **poutbuf, int *poutbuf_size,
7946 const uint8_t *buf, int buf_size)
7948 H264Context *h = s->priv_data;
7949 ParseContext *pc = &h->s.parse_context;
7952 next= find_frame_end(h, buf, buf_size);
7954 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
7960 *poutbuf = (uint8_t *)buf;
7961 *poutbuf_size = buf_size;
7965 static int h264_split(AVCodecContext *avctx,
7966 const uint8_t *buf, int buf_size)
7969 uint32_t state = -1;
7972 for(i=0; i<=buf_size; i++){
7973 if((state&0xFFFFFF1F) == 0x107)
7975 /* if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
7977 if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){
7979 while(i>4 && buf[i-5]==0) i--;
7984 state= (state<<8) | buf[i];
7988 #endif /* CONFIG_H264_PARSER */
7990 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
7991 MpegEncContext * const s = &h->s;
7992 AVCodecContext * const avctx= s->avctx;
7996 for(i=0; i<50; i++){
7997 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
8001 s->current_picture_ptr= NULL;
8010 if(buf_index >= buf_size) break;
8012 for(i = 0; i < h->nal_length_size; i++)
8013 nalsize = (nalsize << 8) | buf[buf_index++];
8014 if(nalsize <= 1 || nalsize > buf_size){
8019 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
8024 // start code prefix search
8025 for(; buf_index + 3 < buf_size; buf_index++){
8026 // this should allways succeed in the first iteration
8027 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
8031 if(buf_index+3 >= buf_size) break;
8036 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
8037 if (ptr==NULL || dst_length <= 0){
8040 while(ptr[dst_length - 1] == 0 && dst_length > 1)
8042 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
8044 if(s->avctx->debug&FF_DEBUG_STARTCODE){
8045 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", h->nal_unit_type, buf_index, buf_size, dst_length);
8048 if (h->is_avc && (nalsize != consumed))
8049 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
8051 buf_index += consumed;
8053 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id
8054 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
8057 switch(h->nal_unit_type){
8059 idr(h); //FIXME ensure we don't loose some frames if there is reordering
8061 init_get_bits(&s->gb, ptr, bit_length);
8063 h->inter_gb_ptr= &s->gb;
8064 s->data_partitioning = 0;
8066 if(decode_slice_header(h) < 0){
8067 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
8070 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE);
8071 if(h->redundant_pic_count==0 && s->hurry_up < 5
8072 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
8073 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
8074 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
8075 && avctx->skip_frame < AVDISCARD_ALL)
8079 init_get_bits(&s->gb, ptr, bit_length);
8081 h->inter_gb_ptr= NULL;
8082 s->data_partitioning = 1;
8084 if(decode_slice_header(h) < 0){
8085 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
8089 init_get_bits(&h->intra_gb, ptr, bit_length);
8090 h->intra_gb_ptr= &h->intra_gb;
8093 init_get_bits(&h->inter_gb, ptr, bit_length);
8094 h->inter_gb_ptr= &h->inter_gb;
8096 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning
8097 && s->context_initialized
8099 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
8100 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
8101 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
8102 && avctx->skip_frame < AVDISCARD_ALL)
8106 init_get_bits(&s->gb, ptr, bit_length);
8110 init_get_bits(&s->gb, ptr, bit_length);
8111 decode_seq_parameter_set(h);
8113 if(s->flags& CODEC_FLAG_LOW_DELAY)
8116 if(avctx->has_b_frames < 2)
8117 avctx->has_b_frames= !s->low_delay;
8120 init_get_bits(&s->gb, ptr, bit_length);
8122 decode_picture_parameter_set(h, bit_length);
8126 case NAL_END_SEQUENCE:
8127 case NAL_END_STREAM:
8128 case NAL_FILLER_DATA:
8130 case NAL_AUXILIARY_SLICE:
8133 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type);
8137 if(!s->current_picture_ptr) return buf_index; //no frame
8139 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
8140 s->current_picture_ptr->pict_type= s->pict_type;
8142 h->prev_frame_num_offset= h->frame_num_offset;
8143 h->prev_frame_num= h->frame_num;
8144 if(s->current_picture_ptr->reference){
8145 h->prev_poc_msb= h->poc_msb;
8146 h->prev_poc_lsb= h->poc_lsb;
8148 if(s->current_picture_ptr->reference)
8149 execute_ref_pic_marking(h, h->mmco, h->mmco_index);
8159 * returns the number of bytes consumed for building the current frame
8161 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
8162 if(s->flags&CODEC_FLAG_TRUNCATED){
8163 pos -= s->parse_context.last_index;
8164 if(pos<0) pos=0; // FIXME remove (unneeded?)
8168 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
8169 if(pos+10>buf_size) pos=buf_size; // oops ;)
8175 static int decode_frame(AVCodecContext *avctx,
8176 void *data, int *data_size,
8177 uint8_t *buf, int buf_size)
8179 H264Context *h = avctx->priv_data;
8180 MpegEncContext *s = &h->s;
8181 AVFrame *pict = data;
8184 s->flags= avctx->flags;
8185 s->flags2= avctx->flags2;
8187 /* no supplementary picture */
8188 if (buf_size == 0) {
8192 if(s->flags&CODEC_FLAG_TRUNCATED){
8193 int next= find_frame_end(h, buf, buf_size);
8195 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
8197 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);
8200 if(h->is_avc && !h->got_avcC) {
8201 int i, cnt, nalsize;
8202 unsigned char *p = avctx->extradata;
8203 if(avctx->extradata_size < 7) {
8204 av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
8208 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);
8211 /* sps and pps in the avcC always have length coded with 2 bytes,
8212 so put a fake nal_length_size = 2 while parsing them */
8213 h->nal_length_size = 2;
8214 // Decode sps from avcC
8215 cnt = *(p+5) & 0x1f; // Number of sps
8217 for (i = 0; i < cnt; i++) {
8218 nalsize = BE_16(p) + 2;
8219 if(decode_nal_units(h, p, nalsize) < 0) {
8220 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
8225 // Decode pps from avcC
8226 cnt = *(p++); // Number of pps
8227 for (i = 0; i < cnt; i++) {
8228 nalsize = BE_16(p) + 2;
8229 if(decode_nal_units(h, p, nalsize) != nalsize) {
8230 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
8235 // Now store right nal length size, that will be use to parse all other nals
8236 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
8237 // Do not reparse avcC
8241 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){
8242 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
8246 buf_index=decode_nal_units(h, buf, buf_size);
8250 //FIXME do something with unavailable reference frames
8252 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size);
8253 if(!s->current_picture_ptr){
8254 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");
8259 Picture *out = s->current_picture_ptr;
8260 #if 0 //decode order
8261 *data_size = sizeof(AVFrame);
8263 /* Sort B-frames into display order */
8264 Picture *cur = s->current_picture_ptr;
8265 Picture *prev = h->delayed_output_pic;
8266 int i, pics, cross_idr, out_of_order, out_idx;
8268 if(h->sps.bitstream_restriction_flag
8269 && s->avctx->has_b_frames < h->sps.num_reorder_frames){
8270 s->avctx->has_b_frames = h->sps.num_reorder_frames;
8275 while(h->delayed_pic[pics]) pics++;
8276 h->delayed_pic[pics++] = cur;
8277 if(cur->reference == 0)
8281 for(i=0; h->delayed_pic[i]; i++)
8282 if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0)
8285 out = h->delayed_pic[0];
8287 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++)
8288 if(h->delayed_pic[i]->poc < out->poc){
8289 out = h->delayed_pic[i];
8293 out_of_order = !cross_idr && prev && out->poc < prev->poc;
8294 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
8296 else if(prev && pics <= s->avctx->has_b_frames)
8298 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15)
8300 ((!cross_idr && prev && out->poc > prev->poc + 2)
8301 || cur->pict_type == B_TYPE)))
8304 s->avctx->has_b_frames++;
8307 else if(out_of_order)
8310 if(out_of_order || pics > s->avctx->has_b_frames){
8311 for(i=out_idx; h->delayed_pic[i]; i++)
8312 h->delayed_pic[i] = h->delayed_pic[i+1];
8318 *data_size = sizeof(AVFrame);
8319 if(prev && prev != out && prev->reference == 1)
8320 prev->reference = 0;
8321 h->delayed_output_pic = out;
8325 *pict= *(AVFrame*)out;
8327 av_log(avctx, AV_LOG_DEBUG, "no picture\n");
8330 assert(pict->data[0] || !*data_size);
8331 ff_print_debug_info(s, pict);
8332 //printf("out %d\n", (int)pict->data[0]);
8335 /* Return the Picture timestamp as the frame number */
8336 /* we substract 1 because it is added on utils.c */
8337 avctx->frame_number = s->picture_number - 1;
8339 return get_consumed_bytes(s, buf_index, buf_size);
8342 static inline void fill_mb_avail(H264Context *h){
8343 MpegEncContext * const s = &h->s;
8344 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
8347 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
8348 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num;
8349 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
8355 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
8356 h->mb_avail[4]= 1; //FIXME move out
8357 h->mb_avail[5]= 0; //FIXME move out
8363 #define SIZE (COUNT*40)
8369 // int int_temp[10000];
8371 AVCodecContext avctx;
8373 dsputil_init(&dsp, &avctx);
8375 init_put_bits(&pb, temp, SIZE);
8376 printf("testing unsigned exp golomb\n");
8377 for(i=0; i<COUNT; i++){
8379 set_ue_golomb(&pb, i);
8380 STOP_TIMER("set_ue_golomb");
8382 flush_put_bits(&pb);
8384 init_get_bits(&gb, temp, 8*SIZE);
8385 for(i=0; i<COUNT; i++){
8388 s= show_bits(&gb, 24);
8391 j= get_ue_golomb(&gb);
8393 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8396 STOP_TIMER("get_ue_golomb");
8400 init_put_bits(&pb, temp, SIZE);
8401 printf("testing signed exp golomb\n");
8402 for(i=0; i<COUNT; i++){
8404 set_se_golomb(&pb, i - COUNT/2);
8405 STOP_TIMER("set_se_golomb");
8407 flush_put_bits(&pb);
8409 init_get_bits(&gb, temp, 8*SIZE);
8410 for(i=0; i<COUNT; i++){
8413 s= show_bits(&gb, 24);
8416 j= get_se_golomb(&gb);
8417 if(j != i - COUNT/2){
8418 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8421 STOP_TIMER("get_se_golomb");
8424 printf("testing 4x4 (I)DCT\n");
8427 uint8_t src[16], ref[16];
8428 uint64_t error= 0, max_error=0;
8430 for(i=0; i<COUNT; i++){
8432 // printf("%d %d %d\n", r1, r2, (r2-r1)*16);
8433 for(j=0; j<16; j++){
8434 ref[j]= random()%255;
8435 src[j]= random()%255;
8438 h264_diff_dct_c(block, src, ref, 4);
8441 for(j=0; j<16; j++){
8442 // printf("%d ", block[j]);
8443 block[j]= block[j]*4;
8444 if(j&1) block[j]= (block[j]*4 + 2)/5;
8445 if(j&4) block[j]= (block[j]*4 + 2)/5;
8449 s->dsp.h264_idct_add(ref, block, 4);
8450 /* for(j=0; j<16; j++){
8451 printf("%d ", ref[j]);
8455 for(j=0; j<16; j++){
8456 int diff= FFABS(src[j] - ref[j]);
8459 max_error= FFMAX(max_error, diff);
8462 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
8464 printf("testing quantizer\n");
8465 for(qp=0; qp<52; qp++){
8467 src1_block[i]= src2_block[i]= random()%255;
8471 printf("Testing NAL layer\n");
8473 uint8_t bitstream[COUNT];
8474 uint8_t nal[COUNT*2];
8476 memset(&h, 0, sizeof(H264Context));
8478 for(i=0; i<COUNT; i++){
8486 for(j=0; j<COUNT; j++){
8487 bitstream[j]= (random() % 255) + 1;
8490 for(j=0; j<zeros; j++){
8491 int pos= random() % COUNT;
8492 while(bitstream[pos] == 0){
8501 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
8503 printf("encoding failed\n");
8507 out= decode_nal(&h, nal, &out_length, &consumed, nal_length);
8511 if(out_length != COUNT){
8512 printf("incorrect length %d %d\n", out_length, COUNT);
8516 if(consumed != nal_length){
8517 printf("incorrect consumed length %d %d\n", nal_length, consumed);
8521 if(memcmp(bitstream, out, COUNT)){
8522 printf("missmatch\n");
8527 printf("Testing RBSP\n");
8535 static int decode_end(AVCodecContext *avctx)
8537 H264Context *h = avctx->priv_data;
8538 MpegEncContext *s = &h->s;
8540 av_freep(&h->rbsp_buffer);
8541 free_tables(h); //FIXME cleanup init stuff perhaps
8544 // memset(h, 0, sizeof(H264Context));
8550 AVCodec h264_decoder = {
8554 sizeof(H264Context),
8559 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
8563 #ifdef CONFIG_H264_PARSER
8564 AVCodecParser h264_parser = {
8566 sizeof(H264Context),