Split SEI code off h264.c.
[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  * Reset SEI values at the beginning of the frame.
622  *
623  * @param h H.264 context.
624  */
625 void ff_h264_reset_sei(H264Context *h);
626
627
628 /*
629 o-o o-o
630  / / /
631 o-o o-o
632  ,---'
633 o-o o-o
634  / / /
635 o-o o-o
636 */
637 //This table must be here because scan8[constant] must be known at compiletime
638 static const uint8_t scan8[16 + 2*4]={
639  4+1*8, 5+1*8, 4+2*8, 5+2*8,
640  6+1*8, 7+1*8, 6+2*8, 7+2*8,
641  4+3*8, 5+3*8, 4+4*8, 5+4*8,
642  6+3*8, 7+3*8, 6+4*8, 7+4*8,
643  1+1*8, 2+1*8,
644  1+2*8, 2+2*8,
645  1+4*8, 2+4*8,
646  1+5*8, 2+5*8,
647 };
648
649 static av_always_inline uint32_t pack16to32(int a, int b){
650 #if HAVE_BIGENDIAN
651    return (b&0xFFFF) + (a<<16);
652 #else
653    return (a&0xFFFF) + (b<<16);
654 #endif
655 }
656
657 /**
658  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
659  */
660 static inline int check_intra4x4_pred_mode(H264Context *h){
661     MpegEncContext * const s = &h->s;
662     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
663     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
664     int i;
665
666     if(!(h->top_samples_available&0x8000)){
667         for(i=0; i<4; i++){
668             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
669             if(status<0){
670                 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);
671                 return -1;
672             } else if(status){
673                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
674             }
675         }
676     }
677
678     if((h->left_samples_available&0x8888)!=0x8888){
679         static const int mask[4]={0x8000,0x2000,0x80,0x20};
680         for(i=0; i<4; i++){
681             if(!(h->left_samples_available&mask[i])){
682                 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
683                 if(status<0){
684                     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);
685                     return -1;
686                 } else if(status){
687                     h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
688                 }
689             }
690         }
691     }
692
693     return 0;
694 } //FIXME cleanup like ff_h264_check_intra_pred_mode
695
696 /**
697  * gets the chroma qp.
698  */
699 static inline int get_chroma_qp(H264Context *h, int t, int qscale){
700     return h->pps.chroma_qp_table[t][qscale];
701 }
702
703 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
704     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
705     MpegEncContext *s = &h->s;
706
707     /* there is no consistent mapping of mvs to neighboring locations that will
708      * make mbaff happy, so we can't move all this logic to fill_caches */
709     if(FRAME_MBAFF){
710         const uint32_t *mb_types = s->current_picture_ptr->mb_type;
711         const int16_t *mv;
712         *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
713         *C = h->mv_cache[list][scan8[0]-2];
714
715         if(!MB_FIELD
716            && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
717             int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
718             if(IS_INTERLACED(mb_types[topright_xy])){
719 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
720                 const int x4 = X4, y4 = Y4;\
721                 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
722                 if(!USES_LIST(mb_type,list))\
723                     return LIST_NOT_USED;\
724                 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
725                 h->mv_cache[list][scan8[0]-2][0] = mv[0];\
726                 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
727                 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;
728
729                 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
730             }
731         }
732         if(topright_ref == PART_NOT_AVAILABLE
733            && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
734            && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
735             if(!MB_FIELD
736                && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
737                 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
738             }
739             if(MB_FIELD
740                && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
741                && i >= scan8[0]+8){
742                 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
743                 SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
744             }
745         }
746 #undef SET_DIAG_MV
747     }
748
749     if(topright_ref != PART_NOT_AVAILABLE){
750         *C= h->mv_cache[list][ i - 8 + part_width ];
751         return topright_ref;
752     }else{
753         tprintf(s->avctx, "topright MV not available\n");
754
755         *C= h->mv_cache[list][ i - 8 - 1 ];
756         return h->ref_cache[list][ i - 8 - 1 ];
757     }
758 }
759
760 /**
761  * gets the predicted MV.
762  * @param n the block index
763  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
764  * @param mx the x component of the predicted motion vector
765  * @param my the y component of the predicted motion vector
766  */
767 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
768     const int index8= scan8[n];
769     const int top_ref=      h->ref_cache[list][ index8 - 8 ];
770     const int left_ref=     h->ref_cache[list][ index8 - 1 ];
771     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
772     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
773     const int16_t * C;
774     int diagonal_ref, match_count;
775
776     assert(part_width==1 || part_width==2 || part_width==4);
777
778 /* mv_cache
779   B . . A T T T T
780   U . . L . . , .
781   U . . L . . . .
782   U . . L . . , .
783   . . . L . . . .
784 */
785
786     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
787     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
788     tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);
789     if(match_count > 1){ //most common
790         *mx= mid_pred(A[0], B[0], C[0]);
791         *my= mid_pred(A[1], B[1], C[1]);
792     }else if(match_count==1){
793         if(left_ref==ref){
794             *mx= A[0];
795             *my= A[1];
796         }else if(top_ref==ref){
797             *mx= B[0];
798             *my= B[1];
799         }else{
800             *mx= C[0];
801             *my= C[1];
802         }
803     }else{
804         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
805             *mx= A[0];
806             *my= A[1];
807         }else{
808             *mx= mid_pred(A[0], B[0], C[0]);
809             *my= mid_pred(A[1], B[1], C[1]);
810         }
811     }
812
813     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);
814 }
815
816
817 #endif /* AVCODEC_H264_H */