93259eca1a9048da8badda5a5c1a6db4934e64ec
[ffmpeg.git] / libavcodec / h264.h
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file libavcodec/h264.h
24  * H.264 / AVC / MPEG4 part10 codec.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27
28 #ifndef AVCODEC_H264_H
29 #define AVCODEC_H264_H
30
31 #include "dsputil.h"
32 #include "cabac.h"
33 #include "mpegvideo.h"
34 #include "h264pred.h"
35
36 #define interlaced_dct interlaced_dct_is_a_bad_name
37 #define mb_intra mb_intra_is_not_initialized_see_mb_type
38
39 #define LUMA_DC_BLOCK_INDEX   25
40 #define CHROMA_DC_BLOCK_INDEX 26
41
42 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
43 #define COEFF_TOKEN_VLC_BITS           8
44 #define TOTAL_ZEROS_VLC_BITS           9
45 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
46 #define RUN_VLC_BITS                   3
47 #define RUN7_VLC_BITS                  6
48
49 #define MAX_SPS_COUNT 32
50 #define MAX_PPS_COUNT 256
51
52 #define MAX_MMCO_COUNT 66
53
54 #define MAX_DELAYED_PIC_COUNT 16
55
56 /* Compiling in interlaced support reduces the speed
57  * of progressive decoding by about 2%. */
58 #define ALLOW_INTERLACE
59
60 #define ALLOW_NOCHROMA
61
62 /**
63  * The maximum number of slices supported by the decoder.
64  * must be a power of 2
65  */
66 #define MAX_SLICES 16
67
68 #ifdef ALLOW_INTERLACE
69 #define MB_MBAFF h->mb_mbaff
70 #define MB_FIELD h->mb_field_decoding_flag
71 #define FRAME_MBAFF h->mb_aff_frame
72 #define FIELD_PICTURE (s->picture_structure != PICT_FRAME)
73 #else
74 #define MB_MBAFF 0
75 #define MB_FIELD 0
76 #define FRAME_MBAFF 0
77 #define FIELD_PICTURE 0
78 #undef  IS_INTERLACED
79 #define IS_INTERLACED(mb_type) 0
80 #endif
81 #define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE)
82
83 #ifdef ALLOW_NOCHROMA
84 #define CHROMA h->sps.chroma_format_idc
85 #else
86 #define CHROMA 1
87 #endif
88
89 #define EXTENDED_SAR          255
90
91 #define MB_TYPE_REF0       MB_TYPE_ACPRED //dirty but it fits in 16 bit
92 #define MB_TYPE_8x8DCT     0x01000000
93 #define IS_REF0(a)         ((a) & MB_TYPE_REF0)
94 #define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
95
96 /* NAL unit types */
97 enum {
98     NAL_SLICE=1,
99     NAL_DPA,
100     NAL_DPB,
101     NAL_DPC,
102     NAL_IDR_SLICE,
103     NAL_SEI,
104     NAL_SPS,
105     NAL_PPS,
106     NAL_AUD,
107     NAL_END_SEQUENCE,
108     NAL_END_STREAM,
109     NAL_FILLER_DATA,
110     NAL_SPS_EXT,
111     NAL_AUXILIARY_SLICE=19
112 };
113
114 /**
115  * SEI message types
116  */
117 typedef enum {
118     SEI_BUFFERING_PERIOD             =  0, ///< buffering period (H.264, D.1.1)
119     SEI_TYPE_PIC_TIMING              =  1, ///< picture timing
120     SEI_TYPE_USER_DATA_UNREGISTERED  =  5, ///< unregistered user data
121     SEI_TYPE_RECOVERY_POINT          =  6  ///< recovery point (frame # to decoder sync)
122 } SEI_Type;
123
124 /**
125  * pic_struct in picture timing SEI message
126  */
127 typedef enum {
128     SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
129     SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
130     SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
131     SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
132     SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
133     SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
134     SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
135     SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
136     SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
137 } SEI_PicStructType;
138
139 /**
140  * Sequence parameter set
141  */
142 typedef struct SPS{
143
144     int profile_idc;
145     int level_idc;
146     int chroma_format_idc;
147     int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
148     int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
149     int poc_type;                      ///< pic_order_cnt_type
150     int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
151     int delta_pic_order_always_zero_flag;
152     int offset_for_non_ref_pic;
153     int offset_for_top_to_bottom_field;
154     int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
155     int ref_frame_count;               ///< num_ref_frames
156     int gaps_in_frame_num_allowed_flag;
157     int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
158     int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
159     int frame_mbs_only_flag;
160     int mb_aff;                        ///<mb_adaptive_frame_field_flag
161     int direct_8x8_inference_flag;
162     int crop;                   ///< frame_cropping_flag
163     unsigned int crop_left;            ///< frame_cropping_rect_left_offset
164     unsigned int crop_right;           ///< frame_cropping_rect_right_offset
165     unsigned int crop_top;             ///< frame_cropping_rect_top_offset
166     unsigned int crop_bottom;          ///< frame_cropping_rect_bottom_offset
167     int vui_parameters_present_flag;
168     AVRational sar;
169     int video_signal_type_present_flag;
170     int full_range;
171     int colour_description_present_flag;
172     enum AVColorPrimaries color_primaries;
173     enum AVColorTransferCharacteristic color_trc;
174     enum AVColorSpace colorspace;
175     int timing_info_present_flag;
176     uint32_t num_units_in_tick;
177     uint32_t time_scale;
178     int fixed_frame_rate_flag;
179     short offset_for_ref_frame[256]; //FIXME dyn aloc?
180     int bitstream_restriction_flag;
181     int num_reorder_frames;
182     int scaling_matrix_present;
183     uint8_t scaling_matrix4[6][16];
184     uint8_t scaling_matrix8[2][64];
185     int nal_hrd_parameters_present_flag;
186     int vcl_hrd_parameters_present_flag;
187     int pic_struct_present_flag;
188     int time_offset_length;
189     int cpb_cnt;                       ///< See H.264 E.1.2
190     int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 +1
191     int cpb_removal_delay_length;      ///< cpb_removal_delay_length_minus1 + 1
192     int dpb_output_delay_length;       ///< dpb_output_delay_length_minus1 + 1
193     int bit_depth_luma;                ///< bit_depth_luma_minus8 + 8
194     int bit_depth_chroma;              ///< bit_depth_chroma_minus8 + 8
195     int residual_color_transform_flag; ///< residual_colour_transform_flag
196 }SPS;
197
198 /**
199  * Picture parameter set
200  */
201 typedef struct PPS{
202     unsigned int sps_id;
203     int cabac;                  ///< entropy_coding_mode_flag
204     int pic_order_present;      ///< pic_order_present_flag
205     int slice_group_count;      ///< num_slice_groups_minus1 + 1
206     int mb_slice_group_map_type;
207     unsigned int ref_count[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
208     int weighted_pred;          ///< weighted_pred_flag
209     int weighted_bipred_idc;
210     int init_qp;                ///< pic_init_qp_minus26 + 26
211     int init_qs;                ///< pic_init_qs_minus26 + 26
212     int chroma_qp_index_offset[2];
213     int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
214     int constrained_intra_pred; ///< constrained_intra_pred_flag
215     int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
216     int transform_8x8_mode;     ///< transform_8x8_mode_flag
217     uint8_t scaling_matrix4[6][16];
218     uint8_t scaling_matrix8[2][64];
219     uint8_t chroma_qp_table[2][64];  ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
220     int chroma_qp_diff;
221 }PPS;
222
223 /**
224  * Memory management control operation opcode.
225  */
226 typedef enum MMCOOpcode{
227     MMCO_END=0,
228     MMCO_SHORT2UNUSED,
229     MMCO_LONG2UNUSED,
230     MMCO_SHORT2LONG,
231     MMCO_SET_MAX_LONG,
232     MMCO_RESET,
233     MMCO_LONG,
234 } MMCOOpcode;
235
236 /**
237  * Memory management control operation.
238  */
239 typedef struct MMCO{
240     MMCOOpcode opcode;
241     int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
242     int long_arg;       ///< index, pic_num, or num long refs depending on opcode
243 } MMCO;
244
245 /**
246  * H264Context
247  */
248 typedef struct H264Context{
249     MpegEncContext s;
250     int nal_ref_idc;
251     int nal_unit_type;
252     uint8_t *rbsp_buffer[2];
253     unsigned int rbsp_buffer_size[2];
254
255     /**
256       * Used to parse AVC variant of h264
257       */
258     int is_avc; ///< this flag is != 0 if codec is avc1
259     int got_avcC; ///< flag used to parse avcC data only once
260     int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
261
262     int chroma_qp[2]; //QPc
263
264     int prev_mb_skipped;
265     int next_mb_skipped;
266
267     //prediction stuff
268     int chroma_pred_mode;
269     int intra16x16_pred_mode;
270
271     int top_mb_xy;
272     int left_mb_xy[2];
273
274     int8_t intra4x4_pred_mode_cache[5*8];
275     int8_t (*intra4x4_pred_mode)[8];
276     H264PredContext hpc;
277     unsigned int topleft_samples_available;
278     unsigned int top_samples_available;
279     unsigned int topright_samples_available;
280     unsigned int left_samples_available;
281     uint8_t (*top_borders[2])[16+2*8];
282     uint8_t left_border[2*(17+2*9)];
283
284     /**
285      * non zero coeff count cache.
286      * is 64 if not available.
287      */
288     DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);
289     uint8_t (*non_zero_count)[16];
290
291     /**
292      * Motion vector cache.
293      */
294     DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]);
295     DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]);
296 #define LIST_NOT_USED -1 //FIXME rename?
297 #define PART_NOT_AVAILABLE -2
298
299     /**
300      * is 1 if the specific list MV&references are set to 0,0,-2.
301      */
302     int mv_cache_clean[2];
303
304     /**
305      * number of neighbors (top and/or left) that used 8x8 dct
306      */
307     int neighbor_transform_size;
308
309     /**
310      * block_offset[ 0..23] for frame macroblocks
311      * block_offset[24..47] for field macroblocks
312      */
313     int block_offset[2*(16+8)];
314
315     uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
316     uint32_t *mb2b8_xy;
317     int b_stride; //FIXME use s->b4_stride
318     int b8_stride;
319
320     int mb_linesize;   ///< may be equal to s->linesize or s->linesize*2, for mbaff
321     int mb_uvlinesize;
322
323     int emu_edge_width;
324     int emu_edge_height;
325
326     int halfpel_flag;
327     int thirdpel_flag;
328
329     int unknown_svq3_flag;
330     int next_slice_index;
331
332     SPS *sps_buffers[MAX_SPS_COUNT];
333     SPS sps; ///< current sps
334
335     PPS *pps_buffers[MAX_PPS_COUNT];
336     /**
337      * current pps
338      */
339     PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
340
341     uint32_t dequant4_buffer[6][52][16];
342     uint32_t dequant8_buffer[2][52][64];
343     uint32_t (*dequant4_coeff[6])[16];
344     uint32_t (*dequant8_coeff[2])[64];
345     int dequant_coeff_pps;     ///< reinit tables when pps changes
346
347     int slice_num;
348     uint16_t *slice_table_base;
349     uint16_t *slice_table;     ///< slice_table_base + 2*mb_stride + 1
350     int slice_type;
351     int slice_type_nos;        ///< S free slice type (SI/SP are remapped to I/P)
352     int slice_type_fixed;
353
354     //interlacing specific flags
355     int mb_aff_frame;
356     int mb_field_decoding_flag;
357     int mb_mbaff;              ///< mb_aff_frame && mb_field_decoding_flag
358
359     DECLARE_ALIGNED_8(uint16_t, sub_mb_type[4]);
360
361     //POC stuff
362     int poc_lsb;
363     int poc_msb;
364     int delta_poc_bottom;
365     int delta_poc[2];
366     int frame_num;
367     int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
368     int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
369     int frame_num_offset;         ///< for POC type 2
370     int prev_frame_num_offset;    ///< for POC type 2
371     int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2
372
373     /**
374      * frame_num for frames or 2*frame_num+1 for field pics.
375      */
376     int curr_pic_num;
377
378     /**
379      * max_frame_num or 2*max_frame_num for field pics.
380      */
381     int max_pic_num;
382
383     //Weighted pred stuff
384     int use_weight;
385     int use_weight_chroma;
386     int luma_log2_weight_denom;
387     int chroma_log2_weight_denom;
388     int luma_weight[2][48];
389     int luma_offset[2][48];
390     int chroma_weight[2][48][2];
391     int chroma_offset[2][48][2];
392     int implicit_weight[48][48];
393
394     //deblock
395     int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0
396     int slice_alpha_c0_offset;
397     int slice_beta_offset;
398
399     int redundant_pic_count;
400
401     int direct_spatial_mv_pred;
402     int dist_scale_factor[16];
403     int dist_scale_factor_field[2][32];
404     int map_col_to_list0[2][16+32];
405     int map_col_to_list0_field[2][2][16+32];
406
407     /**
408      * num_ref_idx_l0/1_active_minus1 + 1
409      */
410     unsigned int ref_count[2];   ///< counts frames or fields, depending on current mb mode
411     unsigned int list_count;
412     Picture *short_ref[32];
413     Picture *long_ref[32];
414     Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
415     Picture ref_list[2][48];         /**< 0..15: frame refs, 16..47: mbaff field refs.
416                                           Reordered version of default_ref_list
417                                           according to picture reordering in slice header */
418     int ref2frm[MAX_SLICES][2][64];  ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
419     Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size?
420     int outputed_poc;
421
422     /**
423      * memory management control operations buffer.
424      */
425     MMCO mmco[MAX_MMCO_COUNT];
426     int mmco_index;
427
428     int long_ref_count;  ///< number of actual long term references
429     int short_ref_count; ///< number of actual short term references
430
431     //data partitioning
432     GetBitContext intra_gb;
433     GetBitContext inter_gb;
434     GetBitContext *intra_gb_ptr;
435     GetBitContext *inter_gb_ptr;
436
437     DECLARE_ALIGNED_16(DCTELEM, mb[16*24]);
438     DCTELEM mb_padding[256];        ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb
439
440     /**
441      * Cabac
442      */
443     CABACContext cabac;
444     uint8_t      cabac_state[460];
445     int          cabac_init_idc;
446
447     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
448     uint16_t     *cbp_table;
449     int cbp;
450     int top_cbp;
451     int left_cbp;
452     /* chroma_pred_mode for i4x4 or i16x16, else 0 */
453     uint8_t     *chroma_pred_mode_table;
454     int         last_qscale_diff;
455     int16_t     (*mvd_table[2])[2];
456     DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);
457     uint8_t     *direct_table;
458     uint8_t     direct_cache[5*8];
459
460     uint8_t zigzag_scan[16];
461     uint8_t zigzag_scan8x8[64];
462     uint8_t zigzag_scan8x8_cavlc[64];
463     uint8_t field_scan[16];
464     uint8_t field_scan8x8[64];
465     uint8_t field_scan8x8_cavlc[64];
466     const uint8_t *zigzag_scan_q0;
467     const uint8_t *zigzag_scan8x8_q0;
468     const uint8_t *zigzag_scan8x8_cavlc_q0;
469     const uint8_t *field_scan_q0;
470     const uint8_t *field_scan8x8_q0;
471     const uint8_t *field_scan8x8_cavlc_q0;
472
473     int x264_build;
474
475     /**
476      * @defgroup multithreading Members for slice based multithreading
477      * @{
478      */
479     struct H264Context *thread_context[MAX_THREADS];
480
481     /**
482      * current slice number, used to initalize slice_num of each thread/context
483      */
484     int current_slice;
485
486     /**
487      * Max number of threads / contexts.
488      * This is equal to AVCodecContext.thread_count unless
489      * multithreaded decoding is impossible, in which case it is
490      * reduced to 1.
491      */
492     int max_contexts;
493
494     /**
495      *  1 if the single thread fallback warning has already been
496      *  displayed, 0 otherwise.
497      */
498     int single_decode_warning;
499
500     int last_slice_type;
501     /** @} */
502
503     int mb_xy;
504
505     uint32_t svq3_watermark_key;
506
507     /**
508      * pic_struct in picture timing SEI message
509      */
510     SEI_PicStructType sei_pic_struct;
511
512     /**
513      * Complement sei_pic_struct
514      * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
515      * However, soft telecined frames may have these values.
516      * This is used in an attempt to flag soft telecine progressive.
517      */
518     int prev_interlaced_frame;
519
520     /**
521      * Bit set of clock types for fields/frames in picture timing SEI message.
522      * For each found ct_type, appropriate bit is set (e.g., bit 1 for
523      * interlaced).
524      */
525     int sei_ct_type;
526
527     /**
528      * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
529      */
530     int sei_dpb_output_delay;
531
532     /**
533      * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
534      */
535     int sei_cpb_removal_delay;
536
537     /**
538      * recovery_frame_cnt from SEI message
539      *
540      * Set to -1 if no recovery point SEI message found or to number of frames
541      * before playback synchronizes. Frames having recovery point are key
542      * frames.
543      */
544     int sei_recovery_frame_cnt;
545
546     int is_complex;
547
548     int luma_weight_flag[2];   ///< 7.4.3.2 luma_weight_lX_flag
549     int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag
550
551     // Timestamp stuff
552     int sei_buffering_period_present;  ///< Buffering period SEI flag
553     int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs
554 }H264Context;
555
556 /**
557  * Decode SEI
558  */
559 int ff_h264_decode_sei(H264Context *h);
560
561 /**
562  * Decode SPS
563  */
564 int ff_h264_decode_seq_parameter_set(H264Context *h);
565
566 /**
567  * Decode PPS
568  */
569 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length);
570
571 /**
572  * Decodes a network abstraction layer unit.
573  * @param consumed is the number of bytes used as input
574  * @param length is the length of the array
575  * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
576  * @returns decoded bytes, might be src+1 if no escapes
577  */
578 const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length);
579
580 /**
581  * identifies the exact end of the bitstream
582  * @return the length of the trailing, or 0 if damaged
583  */
584 int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src);
585
586 /**
587  * frees any data that may have been allocated in the H264 context like SPS, PPS etc.
588  */
589 av_cold void ff_h264_free_context(H264Context *h);
590
591 /**
592  * reconstructs bitstream slice_type.
593  */
594 int ff_h264_get_slice_type(H264Context *h);
595
596 /**
597  * allocates tables.
598  * needs width/height
599  */
600 int ff_h264_alloc_tables(H264Context *h);
601
602 /**
603  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
604  */
605 int ff_h264_check_intra_pred_mode(H264Context *h, int mode);
606
607 void ff_h264_write_back_intra_pred_mode(H264Context *h);
608 void ff_h264_hl_decode_mb(H264Context *h);
609 int ff_h264_frame_start(H264Context *h);
610 av_cold int ff_h264_decode_init(AVCodecContext *avctx);
611 av_cold int ff_h264_decode_end(AVCodecContext *avctx);
612
613 void ff_h264_direct_dist_scale_factor(H264Context * const h);
614 void ff_h264_direct_ref_list_init(H264Context * const h);
615 void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type);
616
617 void ff_h264_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);
618 void ff_h264_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);
619
620 /*
621 o-o o-o
622  / / /
623 o-o o-o
624  ,---'
625 o-o o-o
626  / / /
627 o-o o-o
628 */
629 //This table must be here because scan8[constant] must be known at compiletime
630 static const uint8_t scan8[16 + 2*4]={
631  4+1*8, 5+1*8, 4+2*8, 5+2*8,
632  6+1*8, 7+1*8, 6+2*8, 7+2*8,
633  4+3*8, 5+3*8, 4+4*8, 5+4*8,
634  6+3*8, 7+3*8, 6+4*8, 7+4*8,
635  1+1*8, 2+1*8,
636  1+2*8, 2+2*8,
637  1+4*8, 2+4*8,
638  1+5*8, 2+5*8,
639 };
640
641 static av_always_inline uint32_t pack16to32(int a, int b){
642 #if HAVE_BIGENDIAN
643    return (b&0xFFFF) + (a<<16);
644 #else
645    return (a&0xFFFF) + (b<<16);
646 #endif
647 }
648
649 /**
650  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
651  */
652 static inline int check_intra4x4_pred_mode(H264Context *h){
653     MpegEncContext * const s = &h->s;
654     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
655     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
656     int i;
657
658     if(!(h->top_samples_available&0x8000)){
659         for(i=0; i<4; i++){
660             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
661             if(status<0){
662                 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);
663                 return -1;
664             } else if(status){
665                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
666             }
667         }
668     }
669
670     if((h->left_samples_available&0x8888)!=0x8888){
671         static const int mask[4]={0x8000,0x2000,0x80,0x20};
672         for(i=0; i<4; i++){
673             if(!(h->left_samples_available&mask[i])){
674                 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
675                 if(status<0){
676                     av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
677                     return -1;
678                 } else if(status){
679                     h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
680                 }
681             }
682         }
683     }
684
685     return 0;
686 } //FIXME cleanup like ff_h264_check_intra_pred_mode
687
688 /**
689  * gets the chroma qp.
690  */
691 static inline int get_chroma_qp(H264Context *h, int t, int qscale){
692     return h->pps.chroma_qp_table[t][qscale];
693 }
694
695 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
696     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
697     MpegEncContext *s = &h->s;
698
699     /* there is no consistent mapping of mvs to neighboring locations that will
700      * make mbaff happy, so we can't move all this logic to fill_caches */
701     if(FRAME_MBAFF){
702         const uint32_t *mb_types = s->current_picture_ptr->mb_type;
703         const int16_t *mv;
704         *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
705         *C = h->mv_cache[list][scan8[0]-2];
706
707         if(!MB_FIELD
708            && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
709             int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
710             if(IS_INTERLACED(mb_types[topright_xy])){
711 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
712                 const int x4 = X4, y4 = Y4;\
713                 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
714                 if(!USES_LIST(mb_type,list))\
715                     return LIST_NOT_USED;\
716                 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
717                 h->mv_cache[list][scan8[0]-2][0] = mv[0];\
718                 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
719                 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;
720
721                 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
722             }
723         }
724         if(topright_ref == PART_NOT_AVAILABLE
725            && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
726            && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
727             if(!MB_FIELD
728                && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
729                 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
730             }
731             if(MB_FIELD
732                && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
733                && i >= scan8[0]+8){
734                 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
735                 SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
736             }
737         }
738 #undef SET_DIAG_MV
739     }
740
741     if(topright_ref != PART_NOT_AVAILABLE){
742         *C= h->mv_cache[list][ i - 8 + part_width ];
743         return topright_ref;
744     }else{
745         tprintf(s->avctx, "topright MV not available\n");
746
747         *C= h->mv_cache[list][ i - 8 - 1 ];
748         return h->ref_cache[list][ i - 8 - 1 ];
749     }
750 }
751
752 /**
753  * gets the predicted MV.
754  * @param n the block index
755  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
756  * @param mx the x component of the predicted motion vector
757  * @param my the y component of the predicted motion vector
758  */
759 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
760     const int index8= scan8[n];
761     const int top_ref=      h->ref_cache[list][ index8 - 8 ];
762     const int left_ref=     h->ref_cache[list][ index8 - 1 ];
763     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
764     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
765     const int16_t * C;
766     int diagonal_ref, match_count;
767
768     assert(part_width==1 || part_width==2 || part_width==4);
769
770 /* mv_cache
771   B . . A T T T T
772   U . . L . . , .
773   U . . L . . . .
774   U . . L . . , .
775   . . . L . . . .
776 */
777
778     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
779     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
780     tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);
781     if(match_count > 1){ //most common
782         *mx= mid_pred(A[0], B[0], C[0]);
783         *my= mid_pred(A[1], B[1], C[1]);
784     }else if(match_count==1){
785         if(left_ref==ref){
786             *mx= A[0];
787             *my= A[1];
788         }else if(top_ref==ref){
789             *mx= B[0];
790             *my= B[1];
791         }else{
792             *mx= C[0];
793             *my= C[1];
794         }
795     }else{
796         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
797             *mx= A[0];
798             *my= A[1];
799         }else{
800             *mx= mid_pred(A[0], B[0], C[0]);
801             *my= mid_pred(A[1], B[1], C[1]);
802         }
803     }
804
805     tprintf(h->s.avctx, "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1],                    diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list);
806 }
807
808
809 #endif /* AVCODEC_H264_H */