FFmpeg: libavcodec/h264.h Source File

FFmpeg
h264.h
Go to the documentation of this file.
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
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 "libavutil/intreadwrite.h"
32 #include "dsputil.h"
33 #include "cabac.h"
34 #include "mpegvideo.h"
35 #include "h264dsp.h"
36 #include "h264pred.h"
37 #include "rectangle.h"
38 
39  #define interlaced_dct interlaced_dct_is_a_bad_name
40  #define mb_intra mb_intra_is_not_initialized_see_mb_type
41 
42  #define MAX_SPS_COUNT 32
43  #define MAX_PPS_COUNT 256
44 
45  #define MAX_MMCO_COUNT 66
46 
47  #define MAX_DELAYED_PIC_COUNT 16
48 
49  #define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
50 
51 /* Compiling in interlaced support reduces the speed
52  * of progressive decoding by about 2%. */
53  #define ALLOW_INTERLACE
54 
55  #define FMO 0
56 
57 /**
58  * The maximum number of slices supported by the decoder.
59  * must be a power of 2
60  */
61  #define MAX_SLICES 16
62 
63 #ifdef ALLOW_INTERLACE
64  #define MB_MBAFF h->mb_mbaff
65  #define MB_FIELD h->mb_field_decoding_flag
66  #define FRAME_MBAFF h->mb_aff_frame
67  #define FIELD_PICTURE (s->picture_structure != PICT_FRAME)
68  #define LEFT_MBS 2
69  #define LTOP 0
70  #define LBOT 1
71  #define LEFT(i) (i)
72 #else
73 #define MB_MBAFF 0
74 #define MB_FIELD 0
75 #define FRAME_MBAFF 0
76 #define FIELD_PICTURE 0
77 #undef IS_INTERLACED
78 #define IS_INTERLACED(mb_type) 0
79 #define LEFT_MBS 1
80 #define LTOP 0
81 #define LBOT 0
82 #define LEFT(i) 0
83 #endif
84  #define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE)
85 
86 #ifndef CABAC
87  #define CABAC h->pps.cabac
88 #endif
89 
90  #define CHROMA (h->sps.chroma_format_idc)
91  #define CHROMA422 (h->sps.chroma_format_idc == 2)
92  #define CHROMA444 (h->sps.chroma_format_idc == 3)
93 
94  #define EXTENDED_SAR 255
95 
96  #define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit
97  #define MB_TYPE_8x8DCT 0x01000000
98  #define IS_REF0(a) ((a) & MB_TYPE_REF0)
99  #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT)
100 
101  #define QP_MAX_NUM (51 + 6*6) // The maximum supported qp
102 
103 /* NAL unit types */
104 enum {
105   NAL_SLICE = 1,
106   NAL_DPA,
107   NAL_DPB,
108   NAL_DPC,
109   NAL_IDR_SLICE,
110   NAL_SEI,
111   NAL_SPS,
112   NAL_PPS,
113   NAL_AUD,
114   NAL_END_SEQUENCE,
115   NAL_END_STREAM,
116   NAL_FILLER_DATA,
117   NAL_SPS_EXT,
118   NAL_AUXILIARY_SLICE = 19,
119   NAL_FF_IGNORE = 0xff0f001,
120 };
121 
122 /**
123  * SEI message types
124  */
125  typedef enum {
126   SEI_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1)
127   SEI_TYPE_PIC_TIMING = 1, ///< picture timing
128   SEI_TYPE_USER_DATA_ITU_T_T35 = 4, ///< user data registered by ITU-T Recommendation T.35
129   SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data
130   SEI_TYPE_RECOVERY_POINT = 6 ///< recovery point (frame # to decoder sync)
131 } SEI_Type;
132 
133 /**
134  * pic_struct in picture timing SEI message
135  */
136  typedef enum {
137   SEI_PIC_STRUCT_FRAME = 0, ///< 0: %frame
138   SEI_PIC_STRUCT_TOP_FIELD = 1, ///< 1: top field
139   SEI_PIC_STRUCT_BOTTOM_FIELD = 2, ///< 2: bottom field
140   SEI_PIC_STRUCT_TOP_BOTTOM = 3, ///< 3: top field, bottom field, in that order
141   SEI_PIC_STRUCT_BOTTOM_TOP = 4, ///< 4: bottom field, top field, in that order
142   SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5, ///< 5: top field, bottom field, top field repeated, in that order
143   SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///< 6: bottom field, top field, bottom field repeated, in that order
144   SEI_PIC_STRUCT_FRAME_DOUBLING = 7, ///< 7: %frame doubling
145   SEI_PIC_STRUCT_FRAME_TRIPLING = 8 ///< 8: %frame tripling
146 } SEI_PicStructType;
147 
148 /**
149  * Sequence parameter set
150  */
151  typedef struct SPS {
152   int profile_idc;
153   int level_idc;
154   int chroma_format_idc;
155   int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag
156   int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4
157   int poc_type; ///< pic_order_cnt_type
158   int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4
159   int delta_pic_order_always_zero_flag;
160   int offset_for_non_ref_pic;
161   int offset_for_top_to_bottom_field;
162   int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle
163   int ref_frame_count; ///< num_ref_frames
164   int gaps_in_frame_num_allowed_flag;
165   int mb_width; ///< pic_width_in_mbs_minus1 + 1
166   int mb_height; ///< pic_height_in_map_units_minus1 + 1
167   int frame_mbs_only_flag;
168   int mb_aff; ///< mb_adaptive_frame_field_flag
169   int direct_8x8_inference_flag;
170   int crop; ///< frame_cropping_flag
171   unsigned int crop_left; ///< frame_cropping_rect_left_offset
172   unsigned int crop_right; ///< frame_cropping_rect_right_offset
173   unsigned int crop_top; ///< frame_cropping_rect_top_offset
174   unsigned int crop_bottom; ///< frame_cropping_rect_bottom_offset
175   int vui_parameters_present_flag;
176   AVRational sar;
177   int video_signal_type_present_flag;
178   int full_range;
179   int colour_description_present_flag;
180   enum AVColorPrimaries color_primaries;
181   enum AVColorTransferCharacteristic color_trc;
182   enum AVColorSpace colorspace;
183   int timing_info_present_flag;
184   uint32_t num_units_in_tick;
185   uint32_t time_scale;
186   int fixed_frame_rate_flag;
187   short offset_for_ref_frame[256]; // FIXME dyn aloc?
188   int bitstream_restriction_flag;
189   int num_reorder_frames;
190   int scaling_matrix_present;
191   uint8_t scaling_matrix4[6][16];
192   uint8_t scaling_matrix8[6][64];
193   int nal_hrd_parameters_present_flag;
194   int vcl_hrd_parameters_present_flag;
195   int pic_struct_present_flag;
196   int time_offset_length;
197   int cpb_cnt; ///< See H.264 E.1.2
198   int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 + 1
199   int cpb_removal_delay_length; ///< cpb_removal_delay_length_minus1 + 1
200   int dpb_output_delay_length; ///< dpb_output_delay_length_minus1 + 1
201   int bit_depth_luma; ///< bit_depth_luma_minus8 + 8
202   int bit_depth_chroma; ///< bit_depth_chroma_minus8 + 8
203   int residual_color_transform_flag; ///< residual_colour_transform_flag
204   int constraint_set_flags; ///< constraint_set[0-3]_flag
205   int new; ///< flag to keep track if the decoder context needs re-init due to changed SPS
206 } SPS;
207 
208 /**
209  * Picture parameter set
210  */
211  typedef struct PPS {
212   unsigned int sps_id;
213   int cabac; ///< entropy_coding_mode_flag
214   int pic_order_present; ///< pic_order_present_flag
215   int slice_group_count; ///< num_slice_groups_minus1 + 1
216   int mb_slice_group_map_type;
217   unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1
218   int weighted_pred; ///< weighted_pred_flag
219   int weighted_bipred_idc;
220   int init_qp; ///< pic_init_qp_minus26 + 26
221   int init_qs; ///< pic_init_qs_minus26 + 26
222   int chroma_qp_index_offset[2];
223   int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
224   int constrained_intra_pred; ///< constrained_intra_pred_flag
225   int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
226   int transform_8x8_mode; ///< transform_8x8_mode_flag
227   uint8_t scaling_matrix4[6][16];
228   uint8_t scaling_matrix8[6][64];
229   uint8_t chroma_qp_table[2][QP_MAX_NUM+1]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
230   int chroma_qp_diff;
231 } PPS;
232 
233 /**
234  * Memory management control operation opcode.
235  */
236  typedef enum MMCOOpcode {
237   MMCO_END = 0,
238   MMCO_SHORT2UNUSED,
239   MMCO_LONG2UNUSED,
240   MMCO_SHORT2LONG,
241   MMCO_SET_MAX_LONG,
242   MMCO_RESET,
243   MMCO_LONG,
244 } MMCOOpcode;
245 
246 /**
247  * Memory management control operation.
248  */
249  typedef struct MMCO {
250   MMCOOpcode opcode;
251   int short_pic_num; ///< pic_num without wrapping (pic_num & max_pic_num)
252   int long_arg; ///< index, pic_num, or num long refs depending on opcode
253 } MMCO;
254 
255 /**
256  * H264Context
257  */
258  typedef struct H264Context {
259   MpegEncContext s;
260   H264DSPContext h264dsp;
261   int pixel_shift; ///< 0 for 8-bit H264, 1 for high-bit-depth H264
262   int chroma_qp[2]; // QPc
263 
264   int qp_thresh; ///< QP threshold to skip loopfilter
265 
266   int prev_mb_skipped;
267   int next_mb_skipped;
268 
269  // prediction stuff
270   int chroma_pred_mode;
271   int intra16x16_pred_mode;
272 
273   int topleft_mb_xy;
274   int top_mb_xy;
275   int topright_mb_xy;
276   int left_mb_xy[LEFT_MBS];
277 
278   int topleft_type;
279   int top_type;
280   int topright_type;
281   int left_type[LEFT_MBS];
282 
283   const uint8_t *left_block;
284   int topleft_partition;
285 
286   int8_t intra4x4_pred_mode_cache[5 * 8];
287   int8_t(*intra4x4_pred_mode);
288   H264PredContext hpc;
289   unsigned int topleft_samples_available;
290   unsigned int top_samples_available;
291   unsigned int topright_samples_available;
292   unsigned int left_samples_available;
293   uint8_t (*top_borders[2])[(16 * 3) * 2];
294 
295  /**
296  * non zero coeff count cache.
297  * is 64 if not available.
298  */
299   DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
300 
301   uint8_t (*non_zero_count)[48];
302 
303  /**
304  * Motion vector cache.
305  */
306   DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
307   DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
308  #define LIST_NOT_USED -1 // FIXME rename?
309  #define PART_NOT_AVAILABLE -2
310 
311  /**
312  * number of neighbors (top and/or left) that used 8x8 dct
313  */
314   int neighbor_transform_size;
315 
316  /**
317  * block_offset[ 0..23] for frame macroblocks
318  * block_offset[24..47] for field macroblocks
319  */
320   int block_offset[2 * (16 * 3)];
321 
322   uint32_t *mb2b_xy; // FIXME are these 4 a good idea?
323   uint32_t *mb2br_xy;
324   int b_stride; // FIXME use s->b4_stride
325 
326   int mb_linesize; ///< may be equal to s->linesize or s->linesize * 2, for mbaff
327   int mb_uvlinesize;
328 
329   int emu_edge_width;
330   int emu_edge_height;
331 
332   unsigned current_sps_id; ///< id of the current SPS
333   SPS sps; ///< current sps
334 
335  /**
336  * current pps
337  */
338   PPS pps; // FIXME move to Picture perhaps? (->no) do we need that?
339 
340   uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16]; // FIXME should these be moved down?
341   uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
342   uint32_t(*dequant4_coeff[6])[16];
343   uint32_t(*dequant8_coeff[6])[64];
344 
345   int slice_num;
346   uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1
347   int slice_type;
348   int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P)
349   int slice_type_fixed;
350 
351  // interlacing specific flags
352   int mb_aff_frame;
353   int mb_field_decoding_flag;
354   int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag
355 
356   DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
357 
358  // Weighted pred stuff
359   int use_weight;
360   int use_weight_chroma;
361   int luma_log2_weight_denom;
362   int chroma_log2_weight_denom;
363  // The following 2 can be changed to int8_t but that causes 10cpu cycles speedloss
364   int luma_weight[48][2][2];
365   int chroma_weight[48][2][2][2];
366   int implicit_weight[48][48][2];
367 
368   int direct_spatial_mv_pred;
369   int col_parity;
370   int col_fieldoff;
371   int dist_scale_factor[32];
372   int dist_scale_factor_field[2][32];
373   int map_col_to_list0[2][16 + 32];
374   int map_col_to_list0_field[2][2][16 + 32];
375 
376  /**
377  * num_ref_idx_l0/1_active_minus1 + 1
378  */
379   unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode
380   unsigned int list_count;
381   uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type
382   Picture ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs.
383  * Reordered version of default_ref_list
384  * according to picture reordering in slice header */
385   int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
386 
387  // data partitioning
388   GetBitContext intra_gb;
389   GetBitContext inter_gb;
390   GetBitContext *intra_gb_ptr;
391   GetBitContext *inter_gb_ptr;
392 
393   DECLARE_ALIGNED(16, DCTELEM, mb)[16 * 48 * 2]; ///< as a dct coeffecient is int32_t in high depth, we need to reserve twice the space.
394   DECLARE_ALIGNED(16, DCTELEM, mb_luma_dc)[3][16 * 2];
395   DCTELEM mb_padding[256 * 2]; ///< 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
396 
397  /**
398  * Cabac
399  */
400   CABACContext cabac;
401   uint8_t cabac_state[1024];
402 
403  /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
404   uint16_t *cbp_table;
405   int cbp;
406   int top_cbp;
407   int left_cbp;
408  /* chroma_pred_mode for i4x4 or i16x16, else 0 */
409   uint8_t *chroma_pred_mode_table;
410   int last_qscale_diff;
411   uint8_t (*mvd_table[2])[2];
412   DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
413   uint8_t *direct_table;
414   uint8_t direct_cache[5 * 8];
415 
416   uint8_t zigzag_scan[16];
417   uint8_t zigzag_scan8x8[64];
418   uint8_t zigzag_scan8x8_cavlc[64];
419   uint8_t field_scan[16];
420   uint8_t field_scan8x8[64];
421   uint8_t field_scan8x8_cavlc[64];
422   uint8_t zigzag_scan_q0[16];
423   uint8_t zigzag_scan8x8_q0[64];
424   uint8_t zigzag_scan8x8_cavlc_q0[64];
425   uint8_t field_scan_q0[16];
426   uint8_t field_scan8x8_q0[64];
427   uint8_t field_scan8x8_cavlc_q0[64];
428 
429   int x264_build;
430 
431   int mb_xy;
432 
433   int is_complex;
434 
435  // deblock
436   int deblocking_filter; ///< disable_deblocking_filter_idc with 1 <-> 0
437   int slice_alpha_c0_offset;
438   int slice_beta_offset;
439 
440  // =============================================================
441  // Things below are not used in the MB or more inner code
442 
443   int nal_ref_idc;
444   int nal_unit_type;
445   uint8_t *rbsp_buffer[2];
446   unsigned int rbsp_buffer_size[2];
447 
448  /**
449  * Used to parse AVC variant of h264
450  */
451   int is_avc; ///< this flag is != 0 if codec is avc1
452   int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
453   int got_first; ///< this flag is != 0 if we've parsed a frame
454 
455   int context_reinitialized;
456 
457   SPS *sps_buffers[MAX_SPS_COUNT];
458   PPS *pps_buffers[MAX_PPS_COUNT];
459 
460   int dequant_coeff_pps; ///< reinit tables when pps changes
461 
462   uint16_t *slice_table_base;
463 
464  // POC stuff
465   int poc_lsb;
466   int poc_msb;
467   int delta_poc_bottom;
468   int delta_poc[2];
469   int frame_num;
470   int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0
471   int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0
472   int frame_num_offset; ///< for POC type 2
473   int prev_frame_num_offset; ///< for POC type 2
474   int prev_frame_num; ///< frame_num of the last pic for POC type 1/2
475 
476  /**
477  * frame_num for frames or 2 * frame_num + 1 for field pics.
478  */
479   int curr_pic_num;
480 
481  /**
482  * max_frame_num or 2 * max_frame_num for field pics.
483  */
484   int max_pic_num;
485 
486   int redundant_pic_count;
487 
488   Picture *short_ref[32];
489   Picture *long_ref[32];
490   Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
491   Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
492   int last_pocs[MAX_DELAYED_PIC_COUNT];
493   Picture *next_output_pic;
494   int outputed_poc;
495   int next_outputed_poc;
496 
497  /**
498  * memory management control operations buffer.
499  */
500   MMCO mmco[MAX_MMCO_COUNT];
501   int mmco_index;
502   int mmco_reset;
503 
504   int long_ref_count; ///< number of actual long term references
505   int short_ref_count; ///< number of actual short term references
506 
507   int cabac_init_idc;
508 
509  /**
510  * @name Members for slice based multithreading
511  * @{
512  */
513   struct H264Context *thread_context[MAX_THREADS];
514 
515  /**
516  * current slice number, used to initialize slice_num of each thread/context
517  */
518   int current_slice;
519 
520  /**
521  * Max number of threads / contexts.
522  * This is equal to AVCodecContext.thread_count unless
523  * multithreaded decoding is impossible, in which case it is
524  * reduced to 1.
525  */
526   int max_contexts;
527 
528  /**
529  * 1 if the single thread fallback warning has already been
530  * displayed, 0 otherwise.
531  */
532   int single_decode_warning;
533 
534   int last_slice_type;
535  /** @} */
536 
537  /**
538  * pic_struct in picture timing SEI message
539  */
540   SEI_PicStructType sei_pic_struct;
541 
542  /**
543  * Complement sei_pic_struct
544  * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
545  * However, soft telecined frames may have these values.
546  * This is used in an attempt to flag soft telecine progressive.
547  */
548   int prev_interlaced_frame;
549 
550  /**
551  * Bit set of clock types for fields/frames in picture timing SEI message.
552  * For each found ct_type, appropriate bit is set (e.g., bit 1 for
553  * interlaced).
554  */
555   int sei_ct_type;
556 
557  /**
558  * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
559  */
560   int sei_dpb_output_delay;
561 
562  /**
563  * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
564  */
565   int sei_cpb_removal_delay;
566 
567  /**
568  * recovery_frame_cnt from SEI message
569  *
570  * Set to -1 if no recovery point SEI message found or to number of frames
571  * before playback synchronizes. Frames having recovery point are key
572  * frames.
573  */
574   int sei_recovery_frame_cnt;
575  /**
576  * recovery_frame is the frame_num at which the next frame should
577  * be fully constructed.
578  *
579  * Set to -1 when not expecting a recovery point.
580  */
581   int recovery_frame;
582 
583  /**
584  * Are the SEI recovery points looking valid.
585  */
586   int valid_recovery_point;
587 
588   int luma_weight_flag[2]; ///< 7.4.3.2 luma_weight_lX_flag
589   int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag
590 
591  // Timestamp stuff
592   int sei_buffering_period_present; ///< Buffering period SEI flag
593   int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs
594 
595   int cur_chroma_format_idc;
596   uint8_t *bipred_scratchpad;
597 
598   int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
599 
600   int sync; ///< did we had a keyframe or recovery point
601 
602   uint8_t parse_history[4];
603   int parse_history_count;
604   int parse_last_mb;
605 } H264Context;
606 
607 extern const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1]; ///< One chroma qp table for each possible bit depth (8-14).
608 extern const uint16_t ff_h264_mb_sizes[4];
609 
610 /**
611  * Decode SEI
612  */
613 int ff_h264_decode_sei(H264Context *h);
614 
615 /**
616  * Decode SPS
617  */
618 int ff_h264_decode_seq_parameter_set(H264Context *h);
619 
620 /**
621  * compute profile from sps
622  */
623 int ff_h264_get_profile(SPS *sps);
624 
625 /**
626  * Decode PPS
627  */
628 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length);
629 
630 /**
631  * Decode a network abstraction layer unit.
632  * @param consumed is the number of bytes used as input
633  * @param length is the length of the array
634  * @param dst_length is the number of decoded bytes FIXME here
635  * or a decode rbsp tailing?
636  * @return decoded bytes, might be src+1 if no escapes
637  */
638 const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src,
639  int *dst_length, int *consumed, int length);
640 
641 /**
642  * Free any data that may have been allocated in the H264 context
643  * like SPS, PPS etc.
644  */
645 av_cold void ff_h264_free_context(H264Context *h);
646 
647 /**
648  * Reconstruct bitstream slice_type.
649  */
650 int ff_h264_get_slice_type(const H264Context *h);
651 
652 /**
653  * Allocate tables.
654  * needs width/height
655  */
656 int ff_h264_alloc_tables(H264Context *h);
657 
658 /**
659  * Fill the default_ref_list.
660  */
661 int ff_h264_fill_default_ref_list(H264Context *h);
662 
663 int ff_h264_decode_ref_pic_list_reordering(H264Context *h);
664 void ff_h264_fill_mbaff_ref_list(H264Context *h);
665 void ff_h264_remove_all_refs(H264Context *h);
666 
667 /**
668  * Execute the reference picture marking (memory management control operations).
669  */
670 int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count);
671 
672 int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb,
673  int first_slice);
674 
675 int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice);
676 
677 /**
678  * Check if the top & left blocks are available if needed & change the
679  * dc mode so it only uses the available blocks.
680  */
681 int ff_h264_check_intra4x4_pred_mode(H264Context *h);
682 
683 /**
684  * Check if the top & left blocks are available if needed & change the
685  * dc mode so it only uses the available blocks.
686  */
687 int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma);
688 
689 void ff_h264_hl_decode_mb(H264Context *h);
690 int ff_h264_frame_start(H264Context *h);
691 int ff_h264_decode_extradata(H264Context *h, const uint8_t *buf, int size);
692 av_cold int ff_h264_decode_init(AVCodecContext *avctx);
693 av_cold void ff_h264_decode_init_vlc(void);
694 
695 /**
696  * Decode a macroblock
697  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
698  */
699 int ff_h264_decode_mb_cavlc(H264Context *h);
700 
701 /**
702  * Decode a CABAC coded macroblock
703  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
704  */
705 int ff_h264_decode_mb_cabac(H264Context *h);
706 
707 void ff_h264_init_cabac_states(H264Context *h);
708 
709 void ff_h264_direct_dist_scale_factor(H264Context *const h);
710 void ff_h264_direct_ref_list_init(H264Context *const h);
711 void ff_h264_pred_direct_motion(H264Context *const h, int *mb_type);
712 
713 void ff_h264_filter_mb_fast(H264Context *h, int mb_x, int mb_y,
714  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
715  unsigned int linesize, unsigned int uvlinesize);
716 void ff_h264_filter_mb(H264Context *h, int mb_x, int mb_y,
717  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
718  unsigned int linesize, unsigned int uvlinesize);
719 
720 /**
721  * Reset SEI values at the beginning of the frame.
722  *
723  * @param h H.264 context.
724  */
725 void ff_h264_reset_sei(H264Context *h);
726 
727 /*
728  * o-o o-o
729  * / / /
730  * o-o o-o
731  * ,---'
732  * o-o o-o
733  * / / /
734  * o-o o-o
735  */
736 
737 /* Scan8 organization:
738  * 0 1 2 3 4 5 6 7
739  * 0 DY y y y y y
740  * 1 y Y Y Y Y
741  * 2 y Y Y Y Y
742  * 3 y Y Y Y Y
743  * 4 y Y Y Y Y
744  * 5 DU u u u u u
745  * 6 u U U U U
746  * 7 u U U U U
747  * 8 u U U U U
748  * 9 u U U U U
749  * 10 DV v v v v v
750  * 11 v V V V V
751  * 12 v V V V V
752  * 13 v V V V V
753  * 14 v V V V V
754  * DY/DU/DV are for luma/chroma DC.
755  */
756 
757  #define LUMA_DC_BLOCK_INDEX 48
758  #define CHROMA_DC_BLOCK_INDEX 49
759 
760 // This table must be here because scan8[constant] must be known at compiletime
761  static const uint8_t scan8[16 * 3 + 3] = {
762  4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
763  6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
764  4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
765  6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
766  4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
767  6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
768  4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
769  6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
770  4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
771  6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
772  4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
773  6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
774  0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8
775 };
776 
777  static av_always_inline uint32_t pack16to32(int a, int b)
778 {
779 #if HAVE_BIGENDIAN
780  return (b & 0xFFFF) + (a << 16);
781 #else
782  return (a & 0xFFFF) + (b << 16);
783 #endif
784 }
785 
786  static av_always_inline uint16_t pack8to16(int a, int b)
787 {
788 #if HAVE_BIGENDIAN
789  return (b & 0xFF) + (a << 8);
790 #else
791  return (a & 0xFF) + (b << 8);
792 #endif
793 }
794 
795 /**
796  * Get the chroma qp.
797  */
798  static av_always_inline int get_chroma_qp(H264Context *h, int t, int qscale)
799 {
800  return h->pps.chroma_qp_table[t][qscale];
801 }
802 
803 /**
804  * Get the predicted intra4x4 prediction mode.
805  */
806  static av_always_inline int pred_intra_mode(H264Context *h, int n)
807 {
808  const int index8 = scan8[n];
809  const int left = h->intra4x4_pred_mode_cache[index8 - 1];
810  const int top = h->intra4x4_pred_mode_cache[index8 - 8];
811  const int min = FFMIN(left, top);
812 
813  tprintf(h->s.avctx, "mode:%d %d min:%d\n", left, top, min);
814 
815  if (min < 0)
816  return DC_PRED;
817  else
818  return min;
819 }
820 
821  static av_always_inline void write_back_intra_pred_mode(H264Context *h)
822 {
823  int8_t *i4x4 = h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
824  int8_t *i4x4_cache = h->intra4x4_pred_mode_cache;
825 
826  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
827  i4x4[4] = i4x4_cache[7 + 8 * 3];
828  i4x4[5] = i4x4_cache[7 + 8 * 2];
829  i4x4[6] = i4x4_cache[7 + 8 * 1];
830 }
831 
832  static av_always_inline void write_back_non_zero_count(H264Context *h)
833 {
834  const int mb_xy = h->mb_xy;
835  uint8_t *nnz = h->non_zero_count[mb_xy];
836  uint8_t *nnz_cache = h->non_zero_count_cache;
837 
838  AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
839  AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
840  AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
841  AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
842  AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
843  AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
844  AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
845  AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
846 
847  if (!h->s.chroma_y_shift) {
848  AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
849  AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
850  AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
851  AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
852  }
853 }
854 
855  static av_always_inline void write_back_motion_list(H264Context *h,
856  MpegEncContext *const s,
857  int b_stride,
858  int b_xy, int b8_xy,
859  int mb_type, int list)
860 {
861  int16_t(*mv_dst)[2] = &s->current_picture.f.motion_val[list][b_xy];
862  int16_t(*mv_src)[2] = &h->mv_cache[list][scan8[0]];
863  AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
864  AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
865  AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
866  AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
867  if (CABAC) {
868  uint8_t (*mvd_dst)[2] = &h->mvd_table[list][FMO ? 8 * h->mb_xy
869  : h->mb2br_xy[h->mb_xy]];
870  uint8_t(*mvd_src)[2] = &h->mvd_cache[list][scan8[0]];
871  if (IS_SKIP(mb_type)) {
872  AV_ZERO128(mvd_dst);
873  } else {
874  AV_COPY64(mvd_dst, mvd_src + 8 * 3);
875  AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
876  AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
877  AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
878  }
879  }
880 
881  {
882  int8_t *ref_index = &s->current_picture.f.ref_index[list][b8_xy];
883  int8_t *ref_cache = h->ref_cache[list];
884  ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
885  ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
886  ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
887  ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
888  }
889 }
890 
891  static av_always_inline void write_back_motion(H264Context *h, int mb_type)
892 {
893  MpegEncContext *const s = &h->s;
894  const int b_stride = h->b_stride;
895  const int b_xy = 4 * s->mb_x + 4 * s->mb_y * h->b_stride; // try mb2b(8)_xy
896  const int b8_xy = 4 * h->mb_xy;
897 
898  if (USES_LIST(mb_type, 0)) {
899  write_back_motion_list(h, s, b_stride, b_xy, b8_xy, mb_type, 0);
900  } else {
901  fill_rectangle(&s->current_picture.f.ref_index[0][b8_xy],
902  2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
903  }
904  if (USES_LIST(mb_type, 1))
905  write_back_motion_list(h, s, b_stride, b_xy, b8_xy, mb_type, 1);
906 
907  if (h->slice_type_nos == AV_PICTURE_TYPE_B && CABAC) {
908  if (IS_8X8(mb_type)) {
909  uint8_t *direct_table = &h->direct_table[4 * h->mb_xy];
910  direct_table[1] = h->sub_mb_type[1] >> 1;
911  direct_table[2] = h->sub_mb_type[2] >> 1;
912  direct_table[3] = h->sub_mb_type[3] >> 1;
913  }
914  }
915 }
916 
917  static av_always_inline int get_dct8x8_allowed(H264Context *h)
918 {
919  if (h->sps.direct_8x8_inference_flag)
920  return !(AV_RN64A(h->sub_mb_type) &
921  ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) *
922  0x0001000100010001ULL));
923  else
924  return !(AV_RN64A(h->sub_mb_type) &
925  ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2) *
926  0x0001000100010001ULL));
927 }
928 
929 #endif /* AVCODEC_H264_H */

Generated on Sat May 25 2013 03:58:34 for FFmpeg by   doxygen 1.8.2

AltStyle によって変換されたページ (->オリジナル) /