2007-05-11 01:26:44 +03:00
/*
* H .26 L / H .264 / AVC / JVT / 14496 - 10 / . . . encoder / decoder
* Copyright ( c ) 2003 Michael Niedermayer < michaelni @ gmx . at >
*
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* FFmpeg is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
/**
2010-04-20 17:45:34 +03:00
* @ file
2007-05-11 01:26:44 +03:00
* H .264 / AVC / MPEG4 part10 codec .
* @ author Michael Niedermayer < michaelni @ gmx . at >
*/
2008-08-31 10:39:47 +03:00
# ifndef AVCODEC_H264_H
# define AVCODEC_H264_H
2007-05-11 01:26:44 +03:00
2010-02-18 18:24:31 +02:00
# include "libavutil/intreadwrite.h"
2007-05-11 01:26:44 +03:00
# include "cabac.h"
2014-02-27 20:43:28 +03:00
# include "dsputil.h"
2013-03-06 20:31:14 +03:00
# include "error_resilience.h"
2013-02-03 13:10:05 +03:00
# include "get_bits.h"
2013-01-19 05:34:47 +03:00
# include "h264chroma.h"
2010-03-16 03:17:00 +02:00
# include "h264dsp.h"
2007-09-05 08:30:08 +03:00
# include "h264pred.h"
2013-01-24 07:24:53 +03:00
# include "h264qpel.h"
2014-02-28 15:40:54 +03:00
# include "mpegutils.h"
2014-03-12 12:07:46 +03:00
# include "parser.h"
2014-01-08 16:00:10 +03:00
# include "qpeldsp.h"
2010-01-13 03:59:19 +02:00
# include "rectangle.h"
2014-03-12 12:07:46 +03:00
# include "videodsp.h"
2007-05-11 01:26:44 +03:00
2014-03-17 07:59:01 +03:00
# define H264_MAX_PICTURE_COUNT 36
2014-03-17 08:16:18 +03:00
# define H264_MAX_THREADS 32
2014-02-27 19:07:30 +03:00
2012-05-07 15:13:23 +03:00
# define MAX_SPS_COUNT 32
# define MAX_PPS_COUNT 256
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
# define MAX_MMCO_COUNT 66
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
# define MAX_DELAYED_PIC_COUNT 16
2008-07-16 00:30:04 +03:00
2011-09-10 17:28:53 +03:00
# define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
2007-05-11 01:26:44 +03:00
/* Compiling in interlaced support reduces the speed
* of progressive decoding by about 2 % . */
# define ALLOW_INTERLACE
2010-02-25 04:42:25 +02:00
# define FMO 0
2008-10-29 00:50:16 +02:00
/**
* The maximum number of slices supported by the decoder .
* must be a power of 2
*/
# define MAX_SLICES 16
2007-05-11 01:26:44 +03:00
# ifdef ALLOW_INTERLACE
2014-05-25 04:30:13 +03:00
# define MB_MBAFF(h) (h)->mb_mbaff
# define MB_FIELD(h) (h)->mb_field_decoding_flag
# define FRAME_MBAFF(h) (h)->mb_aff_frame
# define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME)
2011-06-30 01:38:39 +03:00
# define LEFT_MBS 2
2012-05-07 15:13:23 +03:00
# define LTOP 0
# define LBOT 1
# define LEFT(i) (i)
2007-05-11 01:26:44 +03:00
# else
2013-03-09 22:37:11 +03:00
# define MB_MBAFF(h) 0
2013-03-09 22:37:11 +03:00
# define MB_FIELD(h) 0
2013-03-09 22:37:11 +03:00
# define FRAME_MBAFF(h) 0
2013-03-09 22:37:11 +03:00
# define FIELD_PICTURE(h) 0
2007-05-11 01:26:44 +03:00
# undef IS_INTERLACED
# define IS_INTERLACED(mb_type) 0
2011-06-30 01:38:39 +03:00
# define LEFT_MBS 1
2012-05-07 15:13:23 +03:00
# define LTOP 0
# define LBOT 0
# define LEFT(i) 0
2007-05-11 01:26:44 +03:00
# endif
2013-03-09 22:37:11 +03:00
# define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
2007-05-11 01:26:44 +03:00
2010-01-16 07:41:33 +02:00
# ifndef CABAC
2014-05-25 04:30:13 +03:00
# define CABAC(h) (h)->pps.cabac
2010-01-16 07:41:33 +02:00
# endif
2014-05-25 04:30:13 +03:00
# define CHROMA(h) ((h)->sps.chroma_format_idc)
# define CHROMA422(h) ((h)->sps.chroma_format_idc == 2)
# define CHROMA444(h) ((h)->sps.chroma_format_idc == 3)
2011-06-03 11:12:28 +03:00
2012-05-07 15:13:23 +03:00
# define EXTENDED_SAR 255
2008-10-03 16:30:19 +03:00
2012-05-07 15:13:23 +03:00
# define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit
2008-11-24 18:08:21 +02:00
# define MB_TYPE_8x8DCT 0x01000000
# define IS_REF0(a) ((a) & MB_TYPE_REF0)
# define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT)
2012-07-05 02:35:02 +03:00
# define QP_MAX_NUM (51 + 6*6) // The maximum supported qp
2010-01-12 22:59:00 +02:00
2008-10-03 16:30:19 +03:00
/* NAL unit types */
enum {
2014-02-07 01:28:32 +03:00
NAL_SLICE = 1 ,
NAL_DPA = 2 ,
NAL_DPB = 3 ,
NAL_DPC = 4 ,
NAL_IDR_SLICE = 5 ,
NAL_SEI = 6 ,
NAL_SPS = 7 ,
NAL_PPS = 8 ,
NAL_AUD = 9 ,
NAL_END_SEQUENCE = 10 ,
NAL_END_STREAM = 11 ,
NAL_FILLER_DATA = 12 ,
NAL_SPS_EXT = 13 ,
2012-12-16 00:21:23 +03:00
NAL_AUXILIARY_SLICE = 19 ,
NAL_FF_IGNORE = 0xff0f001 ,
2008-10-03 16:30:19 +03:00
} ;
2009-02-08 22:28:12 +02:00
/**
* SEI message types
*/
typedef enum {
2014-02-13 04:26:04 +03:00
SEI_TYPE_BUFFERING_PERIOD = 0 , ///< buffering period (H.264, D.1.1)
2012-05-07 15:13:23 +03:00
SEI_TYPE_PIC_TIMING = 1 , ///< picture timing
2012-10-14 20:17:22 +03:00
SEI_TYPE_USER_DATA_ITU_T_T35 = 4 , ///< user data registered by ITU-T Recommendation T.35
2012-05-07 15:13:23 +03:00
SEI_TYPE_USER_DATA_UNREGISTERED = 5 , ///< unregistered user data
2013-06-28 00:09:06 +03:00
SEI_TYPE_RECOVERY_POINT = 6 , ///< recovery point (frame # to decoder sync)
SEI_TYPE_FRAME_PACKING = 45 , ///< frame packing arrangement
2014-07-02 18:58:19 +03:00
SEI_TYPE_DISPLAY_ORIENTATION = 47 , ///< display orientation
2009-02-08 22:28:12 +02:00
} SEI_Type ;
2008-11-04 20:31:48 +02:00
/**
* pic_struct in picture timing SEI message
*/
typedef enum {
SEI_PIC_STRUCT_FRAME = 0 , ///< 0: %frame
SEI_PIC_STRUCT_TOP_FIELD = 1 , ///< 1: top field
SEI_PIC_STRUCT_BOTTOM_FIELD = 2 , ///< 2: bottom field
SEI_PIC_STRUCT_TOP_BOTTOM = 3 , ///< 3: top field, bottom field, in that order
SEI_PIC_STRUCT_BOTTOM_TOP = 4 , ///< 4: bottom field, top field, in that order
SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5 , ///< 5: top field, bottom field, top field repeated, in that order
SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6 , ///< 6: bottom field, top field, bottom field repeated, in that order
SEI_PIC_STRUCT_FRAME_DOUBLING = 7 , ///< 7: %frame doubling
SEI_PIC_STRUCT_FRAME_TRIPLING = 8 ///< 8: %frame tripling
} SEI_PicStructType ;
2013-06-28 00:09:06 +03:00
/**
* frame_packing_arrangement types
*/
typedef enum {
SEI_FPA_TYPE_CHECKERBOARD = 0 ,
SEI_FPA_TYPE_INTERLEAVE_COLUMN = 1 ,
SEI_FPA_TYPE_INTERLEAVE_ROW = 2 ,
SEI_FPA_TYPE_SIDE_BY_SIDE = 3 ,
SEI_FPA_TYPE_TOP_BOTTOM = 4 ,
SEI_FPA_TYPE_INTERLEAVE_TEMPORAL = 5 ,
SEI_FPA_TYPE_2D = 6 ,
} SEI_FpaType ;
2007-05-11 01:26:44 +03:00
/**
* Sequence parameter set
*/
2012-05-07 15:13:23 +03:00
typedef struct SPS {
2014-02-13 02:43:17 +03:00
unsigned int sps_id ;
2007-05-11 01:26:44 +03:00
int profile_idc ;
int level_idc ;
2008-07-26 05:27:14 +03:00
int chroma_format_idc ;
2007-05-11 01:26:44 +03:00
int transform_bypass ; ///< qpprime_y_zero_transform_bypass_flag
int log2_max_frame_num ; ///< log2_max_frame_num_minus4 + 4
int poc_type ; ///< pic_order_cnt_type
int log2_max_poc_lsb ; ///< log2_max_pic_order_cnt_lsb_minus4
int delta_pic_order_always_zero_flag ;
int offset_for_non_ref_pic ;
int offset_for_top_to_bottom_field ;
int poc_cycle_length ; ///< num_ref_frames_in_pic_order_cnt_cycle
int ref_frame_count ; ///< num_ref_frames
int gaps_in_frame_num_allowed_flag ;
2007-10-02 17:25:47 +03:00
int mb_width ; ///< pic_width_in_mbs_minus1 + 1
int mb_height ; ///< pic_height_in_map_units_minus1 + 1
2007-05-11 01:26:44 +03:00
int frame_mbs_only_flag ;
2012-05-07 15:13:23 +03:00
int mb_aff ; ///< mb_adaptive_frame_field_flag
2007-05-11 01:26:44 +03:00
int direct_8x8_inference_flag ;
2012-05-07 15:13:23 +03:00
int crop ; ///< frame_cropping_flag
2013-02-18 18:32:18 +03:00
/* those 4 are already in luma samples */
2008-04-11 15:57:49 +03:00
unsigned int crop_left ; ///< frame_cropping_rect_left_offset
unsigned int crop_right ; ///< frame_cropping_rect_right_offset
unsigned int crop_top ; ///< frame_cropping_rect_top_offset
unsigned int crop_bottom ; ///< frame_cropping_rect_bottom_offset
2007-05-11 01:26:44 +03:00
int vui_parameters_present_flag ;
AVRational sar ;
2010-01-11 02:31:39 +02:00
int video_signal_type_present_flag ;
int full_range ;
int colour_description_present_flag ;
enum AVColorPrimaries color_primaries ;
enum AVColorTransferCharacteristic color_trc ;
enum AVColorSpace colorspace ;
2007-05-11 01:26:44 +03:00
int timing_info_present_flag ;
uint32_t num_units_in_tick ;
uint32_t time_scale ;
int fixed_frame_rate_flag ;
2012-05-07 15:13:23 +03:00
short offset_for_ref_frame [ 256 ] ; // FIXME dyn aloc?
2007-05-11 01:26:44 +03:00
int bitstream_restriction_flag ;
int num_reorder_frames ;
int scaling_matrix_present ;
uint8_t scaling_matrix4 [ 6 ] [ 16 ] ;
2011-06-03 11:12:28 +03:00
uint8_t scaling_matrix8 [ 6 ] [ 64 ] ;
2008-11-04 20:31:48 +02:00
int nal_hrd_parameters_present_flag ;
int vcl_hrd_parameters_present_flag ;
int pic_struct_present_flag ;
int time_offset_length ;
2012-05-07 15:13:23 +03:00
int cpb_cnt ; ///< See H.264 E.1.2
int initial_cpb_removal_delay_length ; ///< initial_cpb_removal_delay_length_minus1 + 1
int cpb_removal_delay_length ; ///< cpb_removal_delay_length_minus1 + 1
int dpb_output_delay_length ; ///< dpb_output_delay_length_minus1 + 1
int bit_depth_luma ; ///< bit_depth_luma_minus8 + 8
int bit_depth_chroma ; ///< bit_depth_chroma_minus8 + 8
int residual_color_transform_flag ; ///< residual_colour_transform_flag
int constraint_set_flags ; ///< constraint_set[0-3]_flag
2012-11-16 03:12:40 +03:00
int new ; ///< flag to keep track if the decoder context needs re-init due to changed SPS
2012-05-07 15:13:23 +03:00
} SPS ;
2007-05-11 01:26:44 +03:00
/**
* Picture parameter set
*/
2012-05-07 15:13:23 +03:00
typedef struct PPS {
2007-05-11 01:26:44 +03:00
unsigned int sps_id ;
int cabac ; ///< entropy_coding_mode_flag
int pic_order_present ; ///< pic_order_present_flag
int slice_group_count ; ///< num_slice_groups_minus1 + 1
int mb_slice_group_map_type ;
unsigned int ref_count [ 2 ] ; ///< num_ref_idx_l0/1_active_minus1 + 1
int weighted_pred ; ///< weighted_pred_flag
int weighted_bipred_idc ;
int init_qp ; ///< pic_init_qp_minus26 + 26
int init_qs ; ///< pic_init_qs_minus26 + 26
2007-07-06 17:21:37 +03:00
int chroma_qp_index_offset [ 2 ] ;
2007-05-11 01:26:44 +03:00
int deblocking_filter_parameters_present ; ///< deblocking_filter_parameters_present_flag
2012-05-07 15:13:23 +03:00
int constrained_intra_pred ; ///< constrained_intra_pred_flag
int redundant_pic_cnt_present ; ///< redundant_pic_cnt_present_flag
int transform_8x8_mode ; ///< transform_8x8_mode_flag
2007-05-11 01:26:44 +03:00
uint8_t scaling_matrix4 [ 6 ] [ 16 ] ;
2011-06-03 11:12:28 +03:00
uint8_t scaling_matrix8 [ 6 ] [ 64 ] ;
2011-10-06 22:55:44 +03:00
uint8_t chroma_qp_table [ 2 ] [ QP_MAX_NUM + 1 ] ; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
2007-07-06 17:21:37 +03:00
int chroma_qp_diff ;
2012-05-07 15:13:23 +03:00
} PPS ;
2007-05-11 01:26:44 +03:00
2013-06-28 00:09:06 +03:00
/**
* Frame Packing Arrangement Type
*/
typedef struct FPA {
int frame_packing_arrangement_id ;
int frame_packing_arrangement_cancel_flag ; ///< is previous arrangement canceled, -1 if never received
SEI_FpaType frame_packing_arrangement_type ;
int frame_packing_arrangement_repetition_period ;
int content_interpretation_type ;
int quincunx_sampling_flag ;
} FPA ;
2007-05-11 01:26:44 +03:00
/**
* Memory management control operation opcode .
*/
2012-05-07 15:13:23 +03:00
typedef enum MMCOOpcode {
MMCO_END = 0 ,
2007-05-11 01:26:44 +03:00
MMCO_SHORT2UNUSED ,
MMCO_LONG2UNUSED ,
MMCO_SHORT2LONG ,
MMCO_SET_MAX_LONG ,
MMCO_RESET ,
MMCO_LONG ,
} MMCOOpcode ;
/**
* Memory management control operation .
*/
2012-05-07 15:13:23 +03:00
typedef struct MMCO {
2007-05-11 01:26:44 +03:00
MMCOOpcode opcode ;
2007-10-02 17:35:20 +03:00
int short_pic_num ; ///< pic_num without wrapping (pic_num & max_pic_num)
int long_arg ; ///< index, pic_num, or num long refs depending on opcode
2007-05-11 01:26:44 +03:00
} MMCO ;
2014-03-12 11:13:07 +03:00
typedef struct H264Picture {
struct AVFrame f ;
2014-03-18 02:08:54 +03:00
uint8_t avframe_padding [ 1024 ] ; // hack to allow linking to a avutil with larger AVFrame
2014-03-12 11:13:07 +03:00
ThreadFrame tf ;
AVBufferRef * qscale_table_buf ;
int8_t * qscale_table ;
AVBufferRef * motion_val_buf [ 2 ] ;
int16_t ( * motion_val [ 2 ] ) [ 2 ] ;
AVBufferRef * mb_type_buf ;
uint32_t * mb_type ;
AVBufferRef * hwaccel_priv_buf ;
void * hwaccel_picture_private ; ///< hardware accelerator private data
AVBufferRef * ref_index_buf [ 2 ] ;
int8_t * ref_index [ 2 ] ;
int field_poc [ 2 ] ; ///< top/bottom POC
int poc ; ///< frame POC
int frame_num ; ///< frame_num (raw frame_num from slice header)
int mmco_reset ; /**< MMCO_RESET set this 1. Reordering code must
not mix pictures before and after MMCO_RESET . */
int pic_id ; /**< pic_num (short -> no wrap version of pic_num,
pic_num & max_pic_num ; long - > long_pic_num ) */
int long_ref ; ///< 1->long term reference 0->short term reference
2014-03-17 15:31:28 +03:00
int ref_poc [ 2 ] [ 2 ] [ 32 ] ; ///< POCs of the frames/fields used as reference (FIXME need per slice)
2014-03-12 11:13:07 +03:00
int ref_count [ 2 ] [ 2 ] ; ///< number of entries in ref_poc (FIXME need per slice)
int mbaff ; ///< 1 -> MBAFF frame 0-> not MBAFF
int field_picture ; ///< whether or not picture was encoded in separate fields
int needs_realloc ; ///< picture needs to be reallocated (eg due to a frame size change)
int reference ;
int recovered ; ///< picture at IDR or recovery point + recovery count
2014-03-17 07:49:10 +03:00
int invalid_gap ;
2013-11-03 19:24:05 +03:00
int sei_recovery_frame_cnt ;
2014-03-17 07:49:10 +03:00
int crop ;
int crop_left ;
int crop_top ;
2014-03-12 11:13:07 +03:00
} H264Picture ;
2007-05-11 01:26:44 +03:00
/**
* H264Context
*/
2012-05-07 15:13:23 +03:00
typedef struct H264Context {
2013-02-03 13:10:05 +03:00
AVCodecContext * avctx ;
VideoDSPContext vdsp ;
2010-03-16 03:17:00 +02:00
H264DSPContext h264dsp ;
2013-01-19 05:34:47 +03:00
H264ChromaContext h264chroma ;
2013-01-24 07:24:53 +03:00
H264QpelContext h264qpel ;
2013-02-03 13:10:05 +03:00
ParseContext parse_context ;
GetBitContext gb ;
2013-03-03 03:57:26 +03:00
DSPContext dsp ;
2013-02-03 13:10:05 +03:00
ERContext er ;
2014-03-12 11:13:07 +03:00
H264Picture * DPB ;
H264Picture * cur_pic_ptr ;
H264Picture cur_pic ;
2013-02-03 13:10:05 +03:00
2011-03-29 18:48:57 +03:00
int pixel_shift ; ///< 0 for 8-bit H264, 1 for high-bit-depth H264
2012-05-07 15:13:23 +03:00
int chroma_qp [ 2 ] ; // QPc
2007-05-11 01:26:44 +03:00
2010-01-16 13:55:35 +02:00
int qp_thresh ; ///< QP threshold to skip loopfilter
2013-02-18 18:32:18 +03:00
/* coded dimensions -- 16 * mb w/h */
2013-02-03 13:10:05 +03:00
int width , height ;
2013-09-28 03:13:59 +03:00
ptrdiff_t linesize , uvlinesize ;
2013-02-03 13:10:05 +03:00
int chroma_x_shift , chroma_y_shift ;
int qscale ;
int droppable ;
int data_partitioning ;
int coded_picture_number ;
int low_delay ;
int context_initialized ;
int flags ;
int workaround_bugs ;
2007-05-11 01:26:44 +03:00
int prev_mb_skipped ;
int next_mb_skipped ;
2012-05-07 15:13:23 +03:00
// prediction stuff
2007-05-11 01:26:44 +03:00
int chroma_pred_mode ;
int intra16x16_pred_mode ;
2010-02-16 00:07:02 +02:00
int topleft_mb_xy ;
2007-05-11 01:26:44 +03:00
int top_mb_xy ;
2010-02-16 00:07:02 +02:00
int topright_mb_xy ;
2011-06-30 01:38:39 +03:00
int left_mb_xy [ LEFT_MBS ] ;
2007-05-11 01:26:44 +03:00
2010-02-16 00:07:02 +02:00
int topleft_type ;
2010-01-26 15:38:18 +02:00
int top_type ;
2010-02-16 00:07:02 +02:00
int topright_type ;
2011-06-30 01:38:39 +03:00
int left_type [ LEFT_MBS ] ;
2010-01-26 15:38:18 +02:00
2012-05-07 15:13:23 +03:00
const uint8_t * left_block ;
2010-02-16 00:07:02 +02:00
int topleft_partition ;
2012-05-07 15:13:23 +03:00
int8_t intra4x4_pred_mode_cache [ 5 * 8 ] ;
int8_t ( * intra4x4_pred_mode ) ;
2007-09-05 08:30:08 +03:00
H264PredContext hpc ;
2007-05-11 01:26:44 +03:00
unsigned int topleft_samples_available ;
unsigned int top_samples_available ;
unsigned int topright_samples_available ;
unsigned int left_samples_available ;
2012-05-07 15:13:23 +03:00
uint8_t ( * top_borders [ 2 ] ) [ ( 16 * 3 ) * 2 ] ;
2007-05-11 01:26:44 +03:00
/**
* non zero coeff count cache .
* is 64 if not available .
*/
2012-05-07 15:13:23 +03:00
DECLARE_ALIGNED ( 8 , uint8_t , non_zero_count_cache ) [ 15 * 8 ] ;
2010-01-18 01:44:23 +02:00
2011-06-03 11:12:28 +03:00
uint8_t ( * non_zero_count ) [ 48 ] ;
2007-05-11 01:26:44 +03:00
/**
* Motion vector cache .
*/
2012-05-07 15:13:23 +03:00
DECLARE_ALIGNED ( 16 , int16_t , mv_cache ) [ 2 ] [ 5 * 8 ] [ 2 ] ;
DECLARE_ALIGNED ( 8 , int8_t , ref_cache ) [ 2 ] [ 5 * 8 ] ;
# define LIST_NOT_USED -1 // FIXME rename?
2007-05-11 01:26:44 +03:00
# define PART_NOT_AVAILABLE -2
/**
* number of neighbors ( top and / or left ) that used 8 x8 dct
*/
int neighbor_transform_size ;
/**
* block_offset [ 0. .23 ] for frame macroblocks
* block_offset [ 24. .47 ] for field macroblocks
*/
2012-05-07 15:13:23 +03:00
int block_offset [ 2 * ( 16 * 3 ) ] ;
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
uint32_t * mb2b_xy ; // FIXME are these 4 a good idea?
2010-02-25 04:42:25 +02:00
uint32_t * mb2br_xy ;
2012-05-07 15:13:23 +03:00
int b_stride ; // FIXME use s->b4_stride
2007-05-11 01:26:44 +03:00
2013-10-13 03:42:42 +03:00
ptrdiff_t mb_linesize ; ///< may be equal to s->linesize or s->linesize * 2, for mbaff
2013-09-28 03:13:59 +03:00
ptrdiff_t mb_uvlinesize ;
2007-05-11 01:26:44 +03:00
2012-11-16 03:12:40 +03:00
unsigned current_sps_id ; ///< id of the current SPS
2007-05-11 01:26:44 +03:00
SPS sps ; ///< current sps
2014-02-13 02:44:11 +03:00
PPS pps ; ///< current pps
2007-05-11 01:26:44 +03:00
2014-02-04 01:52:38 +03:00
int au_pps_id ; ///< pps_id of current access unit
2012-05-07 15:13:23 +03:00
uint32_t dequant4_buffer [ 6 ] [ QP_MAX_NUM + 1 ] [ 16 ] ; // FIXME should these be moved down?
uint32_t dequant8_buffer [ 6 ] [ QP_MAX_NUM + 1 ] [ 64 ] ;
uint32_t ( * dequant4_coeff [ 6 ] ) [ 16 ] ;
uint32_t ( * dequant8_coeff [ 6 ] ) [ 64 ] ;
2007-05-11 01:26:44 +03:00
int slice_num ;
2012-05-07 15:13:23 +03:00
uint16_t * slice_table ; ///< slice_table_base + 2*mb_stride + 1
2007-05-11 01:26:44 +03:00
int slice_type ;
2012-05-07 15:13:23 +03:00
int slice_type_nos ; ///< S free slice type (SI/SP are remapped to I/P)
2007-05-11 01:26:44 +03:00
int slice_type_fixed ;
2012-05-07 15:13:23 +03:00
// interlacing specific flags
2007-05-11 01:26:44 +03:00
int mb_aff_frame ;
int mb_field_decoding_flag ;
2012-05-07 15:13:23 +03:00
int mb_mbaff ; ///< mb_aff_frame && mb_field_decoding_flag
2013-02-03 13:10:05 +03:00
int picture_structure ;
int first_field ;
2007-05-11 01:26:44 +03:00
2010-03-06 16:24:59 +02:00
DECLARE_ALIGNED ( 8 , uint16_t , sub_mb_type ) [ 4 ] ;
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
// Weighted pred stuff
2007-05-11 01:26:44 +03:00
int use_weight ;
int use_weight_chroma ;
int luma_log2_weight_denom ;
int chroma_log2_weight_denom ;
2012-05-07 15:13:23 +03:00
// The following 2 can be changed to int8_t but that causes 10cpu cycles speedloss
2010-03-03 23:10:08 +02:00
int luma_weight [ 48 ] [ 2 ] [ 2 ] ;
int chroma_weight [ 48 ] [ 2 ] [ 2 ] [ 2 ] ;
2010-03-31 00:05:11 +03:00
int implicit_weight [ 48 ] [ 48 ] [ 2 ] ;
2007-05-11 01:26:44 +03:00
int direct_spatial_mv_pred ;
2010-02-08 01:15:53 +02:00
int col_parity ;
int col_fieldoff ;
2012-12-17 23:36:05 +03:00
int dist_scale_factor [ 32 ] ;
2008-09-21 05:39:09 +03:00
int dist_scale_factor_field [ 2 ] [ 32 ] ;
2012-05-07 15:13:23 +03:00
int map_col_to_list0 [ 2 ] [ 16 + 32 ] ;
int map_col_to_list0_field [ 2 ] [ 2 ] [ 16 + 32 ] ;
2007-05-11 01:26:44 +03:00
/**
* num_ref_idx_l0 / 1 _active_minus1 + 1
*/
2012-05-07 15:13:23 +03:00
unsigned int ref_count [ 2 ] ; ///< counts frames or fields, depending on current mb mode
2007-05-11 01:26:44 +03:00
unsigned int list_count ;
2012-05-07 15:13:23 +03:00
uint8_t * list_counts ; ///< Array of list_count per MB specifying the slice type
2014-03-12 11:13:07 +03:00
H264Picture ref_list [ 2 ] [ 48 ] ; /**< 0..15: frame refs, 16..47: mbaff field refs.
2012-05-07 15:13:23 +03:00
* Reordered version of default_ref_list
* according to picture reordering in slice header */
int ref2frm [ MAX_SLICES ] [ 2 ] [ 64 ] ; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
// data partitioning
2007-05-11 01:26:44 +03:00
GetBitContext intra_gb ;
GetBitContext inter_gb ;
GetBitContext * intra_gb_ptr ;
GetBitContext * inter_gb_ptr ;
2013-02-18 01:52:24 +03:00
const uint8_t * intra_pcm_ptr ;
2014-07-10 16:29:54 +03:00
DECLARE_ALIGNED ( 16 , int16_t , mb ) [ 16 * 48 * 2 ] ; ///< as a dct coefficient is int32_t in high depth, we need to reserve twice the space.
2013-01-20 03:02:29 +03:00
DECLARE_ALIGNED ( 16 , int16_t , mb_luma_dc ) [ 3 ] [ 16 * 2 ] ;
int16_t 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
2007-05-11 01:26:44 +03:00
/**
* Cabac
*/
CABACContext cabac ;
2012-05-07 15:13:23 +03:00
uint8_t cabac_state [ 1024 ] ;
2007-05-11 01:26:44 +03:00
2012-05-07 15:13:23 +03:00
/* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
uint16_t * cbp_table ;
2007-05-11 01:26:44 +03:00
int cbp ;
int top_cbp ;
int left_cbp ;
/* chroma_pred_mode for i4x4 or i16x16, else 0 */
2012-05-07 15:13:23 +03:00
uint8_t * chroma_pred_mode_table ;
int last_qscale_diff ;
uint8_t ( * mvd_table [ 2 ] ) [ 2 ] ;
DECLARE_ALIGNED ( 16 , uint8_t , mvd_cache ) [ 2 ] [ 5 * 8 ] [ 2 ] ;
uint8_t * direct_table ;
uint8_t direct_cache [ 5 * 8 ] ;
2007-05-11 01:26:44 +03:00
uint8_t zigzag_scan [ 16 ] ;
uint8_t zigzag_scan8x8 [ 64 ] ;
uint8_t zigzag_scan8x8_cavlc [ 64 ] ;
uint8_t field_scan [ 16 ] ;
uint8_t field_scan8x8 [ 64 ] ;
uint8_t field_scan8x8_cavlc [ 64 ] ;
2012-05-31 21:19:56 +03:00
uint8_t zigzag_scan_q0 [ 16 ] ;
uint8_t zigzag_scan8x8_q0 [ 64 ] ;
uint8_t zigzag_scan8x8_cavlc_q0 [ 64 ] ;
uint8_t field_scan_q0 [ 16 ] ;
uint8_t field_scan8x8_q0 [ 64 ] ;
uint8_t field_scan8x8_cavlc_q0 [ 64 ] ;
2007-05-11 01:26:44 +03:00
int x264_build ;
2007-09-05 19:18:15 +03:00
2013-02-03 13:10:05 +03:00
int mb_x , mb_y ;
int resync_mb_x ;
int resync_mb_y ;
int mb_skip_run ;
int mb_height , mb_width ;
int mb_stride ;
int mb_num ;
2010-03-03 22:36:56 +02:00
int mb_xy ;
int is_complex ;
2012-05-07 15:13:23 +03:00
// deblock
int deblocking_filter ; ///< disable_deblocking_filter_idc with 1 <-> 0
2010-03-03 22:36:56 +02:00
int slice_alpha_c0_offset ;
int slice_beta_offset ;
2012-05-07 15:13:23 +03:00
// =============================================================
// Things below are not used in the MB or more inner code
2010-03-03 22:36:56 +02:00
int nal_ref_idc ;
int nal_unit_type ;
uint8_t * rbsp_buffer [ 2 ] ;
unsigned int rbsp_buffer_size [ 2 ] ;
/**
* Used to parse AVC variant of h264
*/
2012-05-07 15:13:23 +03:00
int is_avc ; ///< this flag is != 0 if codec is avc1
int nal_length_size ; ///< Number of bytes used for nal length (1, 2 or 4)
int got_first ; ///< this flag is != 0 if we've parsed a frame
2010-03-03 22:36:56 +02:00
2013-02-03 13:10:05 +03:00
int bit_depth_luma ; ///< luma bit depth from sps to detect changes
int chroma_format_idc ; ///< chroma format from sps to detect changes
2012-12-19 20:46:48 +03:00
2010-03-03 22:36:56 +02:00
SPS * sps_buffers [ MAX_SPS_COUNT ] ;
PPS * pps_buffers [ MAX_PPS_COUNT ] ;
2012-05-07 15:13:23 +03:00
int dequant_coeff_pps ; ///< reinit tables when pps changes
2010-03-03 22:36:56 +02:00
uint16_t * slice_table_base ;
2012-05-07 15:13:23 +03:00
// POC stuff
2010-03-03 22:36:56 +02:00
int poc_lsb ;
int poc_msb ;
int delta_poc_bottom ;
int delta_poc [ 2 ] ;
int frame_num ;
2012-05-07 15:13:23 +03:00
int prev_poc_msb ; ///< poc_msb of the last reference pic for POC type 0
int prev_poc_lsb ; ///< poc_lsb of the last reference pic for POC type 0
int frame_num_offset ; ///< for POC type 2
int prev_frame_num_offset ; ///< for POC type 2
int prev_frame_num ; ///< frame_num of the last pic for POC type 1/2
2010-03-03 22:36:56 +02:00
/**
2012-05-07 15:13:23 +03:00
* frame_num for frames or 2 * frame_num + 1 for field pics .
2010-03-03 22:36:56 +02:00
*/
int curr_pic_num ;
/**
2012-05-07 15:13:23 +03:00
* max_frame_num or 2 * max_frame_num for field pics .
2010-03-03 22:36:56 +02:00
*/
int max_pic_num ;
int redundant_pic_count ;
2014-03-12 11:13:07 +03:00
H264Picture default_ref_list [ 2 ] [ 32 ] ; ///< base reference list for all slices of a coded picture
H264Picture * short_ref [ 32 ] ;
H264Picture * long_ref [ 32 ] ;
H264Picture * delayed_pic [ MAX_DELAYED_PIC_COUNT + 2 ] ; // FIXME size?
2011-10-29 23:44:50 +03:00
int last_pocs [ MAX_DELAYED_PIC_COUNT ] ;
2014-03-12 11:13:07 +03:00
H264Picture * next_output_pic ;
2010-03-03 22:36:56 +02:00
int outputed_poc ;
2011-03-22 23:36:57 +02:00
int next_outputed_poc ;
2010-03-03 22:36:56 +02:00
/**
* memory management control operations buffer .
*/
MMCO mmco [ MAX_MMCO_COUNT ] ;
int mmco_index ;
2011-11-30 09:22:44 +03:00
int mmco_reset ;
2010-03-03 22:36:56 +02:00
2012-05-07 15:13:23 +03:00
int long_ref_count ; ///< number of actual long term references
int short_ref_count ; ///< number of actual short term references
2010-03-03 22:36:56 +02:00
2012-05-07 15:13:23 +03:00
int cabac_init_idc ;
2010-03-03 22:36:56 +02:00
2007-09-05 19:18:15 +03:00
/**
2011-07-01 16:32:21 +03:00
* @ name Members for slice based multithreading
2007-09-05 19:18:15 +03:00
* @ {
*/
2014-02-28 15:21:59 +03:00
struct H264Context * thread_context [ H264_MAX_THREADS ] ;
2007-09-05 19:18:15 +03:00
/**
2012-06-28 23:01:06 +03:00
* current slice number , used to initialize slice_num of each thread / context
2007-09-05 19:18:15 +03:00
*/
int current_slice ;
/**
* Max number of threads / contexts .
* This is equal to AVCodecContext . thread_count unless
* multithreaded decoding is impossible , in which case it is
* reduced to 1.
*/
int max_contexts ;
2013-02-03 13:10:05 +03:00
int slice_context_count ;
2007-09-05 19:18:15 +03:00
/**
* 1 if the single thread fallback warning has already been
* displayed , 0 otherwise .
*/
int single_decode_warning ;
2013-02-03 13:10:05 +03:00
enum AVPictureType pict_type ;
2007-09-05 19:18:15 +03:00
int last_slice_type ;
2013-02-20 21:43:58 +03:00
unsigned int last_ref_count [ 2 ] ;
2007-09-05 19:18:15 +03:00
/** @} */
2008-11-04 20:31:48 +02:00
/**
* pic_struct in picture timing SEI message
*/
SEI_PicStructType sei_pic_struct ;
2008-12-16 22:26:22 +02:00
2009-03-04 21:37:19 +02:00
/**
2009-06-10 00:16:40 +03:00
* Complement sei_pic_struct
* SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames .
* However , soft telecined frames may have these values .
* This is used in an attempt to flag soft telecine progressive .
*/
int prev_interlaced_frame ;
2013-02-20 18:34:58 +03:00
/**
* frame_packing_arrangment SEI message
*/
int sei_frame_packing_present ;
int frame_packing_arrangement_type ;
int content_interpretation_type ;
int quincunx_subsampling ;
2014-07-02 18:58:19 +03:00
/**
* display orientation SEI message
*/
int sei_display_orientation_present ;
int sei_anticlockwise_rotation ;
int sei_hflip , sei_vflip ;
2009-06-10 00:16:40 +03:00
/**
2009-03-04 21:37:19 +02:00
* Bit set of clock types for fields / frames in picture timing SEI message .
* For each found ct_type , appropriate bit is set ( e . g . , bit 1 for
* interlaced ) .
*/
int sei_ct_type ;
2009-02-18 02:36:07 +02:00
/**
* dpb_output_delay in picture timing SEI message , see H .264 C .2 .2
*/
int sei_dpb_output_delay ;
2009-02-18 02:38:10 +02:00
/**
* cpb_removal_delay in picture timing SEI message , see H .264 C .1 .2
*/
int sei_cpb_removal_delay ;
2009-02-10 01:04:16 +02:00
/**
* recovery_frame_cnt from SEI message
*
* Set to - 1 if no recovery point SEI message found or to number of frames
* before playback synchronizes . Frames having recovery point are key
* frames .
*/
int sei_recovery_frame_cnt ;
2013-11-01 13:33:36 +03:00
/**
* Are the SEI recovery points looking valid .
*/
int valid_recovery_point ;
FPA sei_fpa ;
2011-09-18 23:10:52 +03:00
/**
* recovery_frame is the frame_num at which the next frame should
* be fully constructed .
*
* Set to - 1 when not expecting a recovery point .
*/
int recovery_frame ;
2009-02-10 01:04:16 +02:00
2013-10-11 19:51:50 +03:00
/**
* We have seen an IDR , so all the following frames in coded order are correctly
* decodable .
*/
# define FRAME_RECOVERED_IDR (1 << 0)
/**
* Sufficient number of frames have been decoded since a SEI recovery point ,
* so all the following frames in presentation order are correct .
*/
# define FRAME_RECOVERED_SEI (1 << 1)
2012-08-20 06:36:52 +03:00
2013-10-11 19:51:50 +03:00
int frame_recovered ; ///< Initial frame has been completely recovered
2013-06-28 00:09:06 +03:00
2014-06-04 05:25:14 +03:00
int has_recovery_point ;
2012-05-07 15:13:23 +03:00
int luma_weight_flag [ 2 ] ; ///< 7.4.3.2 luma_weight_lX_flag
int chroma_weight_flag [ 2 ] ; ///< 7.4.3.2 chroma_weight_lX_flag
2009-02-19 01:33:30 +02:00
// Timestamp stuff
2012-05-07 15:13:23 +03:00
int sei_buffering_period_present ; ///< Buffering period SEI flag
int initial_cpb_removal_delay [ 32 ] ; ///< Initial timestamps for CPBs
2011-08-15 01:39:55 +03:00
int cur_chroma_format_idc ;
2012-11-27 21:12:45 +03:00
uint8_t * bipred_scratchpad ;
2011-09-12 07:06:43 +03:00
int16_t slice_row [ MAX_SLICES ] ; ///< to detect when MAX_SLICES is too low
2011-09-17 20:59:48 +03:00
2011-10-27 18:53:29 +03:00
uint8_t parse_history [ 4 ] ;
int parse_history_count ;
int parse_last_mb ;
2013-02-03 13:10:05 +03:00
uint8_t * edge_emu_buffer ;
int16_t * dc_val_base ;
2013-02-19 04:47:47 +03:00
2012-11-21 23:34:46 +03:00
AVBufferPool * qscale_table_pool ;
AVBufferPool * mb_type_pool ;
AVBufferPool * motion_val_pool ;
AVBufferPool * ref_index_pool ;
2014-02-27 20:43:28 +03:00
/* Motion Estimation */
qpel_mc_func ( * qpel_put ) [ 16 ] ;
qpel_mc_func ( * qpel_avg ) [ 16 ] ;
2012-05-07 15:13:23 +03:00
} H264Context ;
2010-01-12 21:33:45 +02:00
2012-07-05 02:35:02 +03:00
extern const uint8_t ff_h264_chroma_qp [ 7 ] [ QP_MAX_NUM + 1 ] ; ///< One chroma qp table for each possible bit depth (8-14).
2012-04-04 15:53:25 +03:00
extern const uint16_t ff_h264_mb_sizes [ 4 ] ;
2010-01-12 21:33:45 +02:00
2009-02-21 21:54:14 +02:00
/**
* Decode SEI
*/
int ff_h264_decode_sei ( H264Context * h ) ;
/**
* Decode SPS
*/
int ff_h264_decode_seq_parameter_set ( H264Context * h ) ;
2011-01-28 23:15:47 +02:00
/**
* compute profile from sps
*/
int ff_h264_get_profile ( SPS * sps ) ;
2009-02-21 21:54:14 +02:00
/**
* Decode PPS
*/
int ff_h264_decode_picture_parameter_set ( H264Context * h , int bit_length ) ;
/**
2010-06-30 18:38:06 +03:00
* Decode a network abstraction layer unit .
2009-02-21 21:54:14 +02:00
* @ param consumed is the number of bytes used as input
* @ param length is the length of the array
2012-05-07 15:13:23 +03:00
* @ param dst_length is the number of decoded bytes FIXME here
* or a decode rbsp tailing ?
2010-03-30 18:50:57 +03:00
* @ return decoded bytes , might be src + 1 if no escapes
2009-02-21 21:54:14 +02:00
*/
2012-05-07 15:13:23 +03:00
const uint8_t * ff_h264_decode_nal ( H264Context * h , const uint8_t * src ,
int * dst_length , int * consumed , int length ) ;
2009-02-21 21:54:14 +02:00
2009-04-10 10:01:55 +03:00
/**
2012-05-07 15:13:23 +03:00
* Free any data that may have been allocated in the H264 context
* like SPS , PPS etc .
2009-04-10 10:01:55 +03:00
*/
2013-02-09 18:19:27 +03:00
void ff_h264_free_context ( H264Context * h ) ;
2009-04-10 10:01:55 +03:00
2010-01-09 18:20:41 +02:00
/**
2010-06-30 18:38:06 +03:00
* Reconstruct bitstream slice_type .
2010-01-09 18:20:41 +02:00
*/
2010-01-24 18:37:12 +02:00
int ff_h264_get_slice_type ( const H264Context * h ) ;
2010-01-09 18:20:41 +02:00
2010-01-12 07:30:31 +02:00
/**
2010-06-30 18:38:06 +03:00
* Allocate tables .
2010-01-12 07:30:31 +02:00
* needs width / height
*/
int ff_h264_alloc_tables ( H264Context * h ) ;
2010-01-12 22:59:00 +02:00
/**
2010-06-30 18:38:06 +03:00
* Fill the default_ref_list .
2010-01-12 22:59:00 +02:00
*/
int ff_h264_fill_default_ref_list ( H264Context * h ) ;
int ff_h264_decode_ref_pic_list_reordering ( H264Context * h ) ;
void ff_h264_fill_mbaff_ref_list ( H264Context * h ) ;
void ff_h264_remove_all_refs ( H264Context * h ) ;
/**
2010-06-30 18:38:06 +03:00
* Execute the reference picture marking ( memory management control operations ) .
2010-01-12 22:59:00 +02:00
*/
int ff_h264_execute_ref_pic_marking ( H264Context * h , MMCO * mmco , int mmco_count ) ;
2013-01-14 08:46:44 +03:00
int ff_h264_decode_ref_pic_marking ( H264Context * h , GetBitContext * gb ,
int first_slice ) ;
2010-01-12 22:59:00 +02:00
2013-01-14 22:07:53 +03:00
int ff_generate_sliding_window_mmcos ( H264Context * h , int first_slice ) ;
2010-07-05 15:42:19 +03:00
2010-01-12 23:17:26 +02:00
/**
2012-05-07 15:13:23 +03:00
* Check if the top & left blocks are available if needed & change the
* dc mode so it only uses the available blocks .
2010-01-12 23:17:26 +02:00
*/
int ff_h264_check_intra4x4_pred_mode ( H264Context * h ) ;
2010-01-12 07:30:31 +02:00
/**
2012-05-07 15:13:23 +03:00
* Check if the top & left blocks are available if needed & change the
* dc mode so it only uses the available blocks .
2010-01-12 07:30:31 +02:00
*/
2012-02-10 09:57:01 +03:00
int ff_h264_check_intra_pred_mode ( H264Context * h , int mode , int is_chroma ) ;
2010-01-12 07:30:31 +02:00
void ff_h264_hl_decode_mb ( H264Context * h ) ;
2011-09-23 06:42:45 +03:00
int ff_h264_decode_extradata ( H264Context * h , const uint8_t * buf , int size ) ;
2013-02-09 18:19:27 +03:00
int ff_h264_decode_init ( AVCodecContext * avctx ) ;
void ff_h264_decode_init_vlc ( void ) ;
2010-01-13 03:59:19 +02:00
/**
2010-06-30 18:38:06 +03:00
* Decode a macroblock
2012-05-07 15:13:23 +03:00
* @ return 0 if OK , ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
2010-01-13 03:59:19 +02:00
*/
int ff_h264_decode_mb_cavlc ( H264Context * h ) ;
2010-01-12 07:30:31 +02:00
2010-01-13 04:35:36 +02:00
/**
2010-06-30 18:38:06 +03:00
* Decode a CABAC coded macroblock
2012-05-07 15:13:23 +03:00
* @ return 0 if OK , ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
2010-01-13 04:35:36 +02:00
*/
int ff_h264_decode_mb_cabac ( H264Context * h ) ;
void ff_h264_init_cabac_states ( H264Context * h ) ;
2014-03-19 18:52:47 +03:00
void h264_init_dequant_tables ( H264Context * h ) ;
2012-05-07 15:13:23 +03:00
void ff_h264_direct_dist_scale_factor ( H264Context * const h ) ;
void ff_h264_direct_ref_list_init ( H264Context * const h ) ;
void ff_h264_pred_direct_motion ( H264Context * const h , int * mb_type ) ;
2010-01-12 16:32:58 +02:00
2012-05-07 15:13:23 +03:00
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 ) ;
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 ) ;
2010-01-12 08:01:55 +02:00
2010-01-12 20:54:40 +02:00
/**
* Reset SEI values at the beginning of the frame .
*
* @ param h H .264 context .
*/
void ff_h264_reset_sei ( H264Context * h ) ;
2013-06-28 00:09:06 +03:00
/**
* Get stereo_mode string from the h264 frame_packing_arrangement
* @ param h H .264 context .
*/
const char * ff_h264_sei_stereo_mode ( H264Context * h ) ;
2010-01-12 07:30:31 +02:00
/*
2012-05-07 15:13:23 +03:00
* o - o o - o
* / / /
* o - o o - o
* , - - - '
* o - o o - o
* / / /
* o - o o - o
*/
2011-01-14 23:36:16 +02:00
/* Scan8 organization:
2011-06-03 11:12:28 +03:00
* 0 1 2 3 4 5 6 7
* 0 DY y y y y y
* 1 y Y Y Y Y
* 2 y Y Y Y Y
* 3 y Y Y Y Y
* 4 y Y Y Y Y
* 5 DU u u u u u
* 6 u U U U U
* 7 u U U U U
* 8 u U U U U
* 9 u U U U U
* 10 DV v v v v v
* 11 v V V V V
* 12 v V V V V
* 13 v V V V V
* 14 v V V V V
2011-01-14 23:36:16 +02:00
* DY / DU / DV are for luma / chroma DC .
*/
2011-06-03 11:12:28 +03:00
# define LUMA_DC_BLOCK_INDEX 48
# define CHROMA_DC_BLOCK_INDEX 49
2012-05-07 15:13:23 +03:00
// This table must be here because scan8[constant] must be known at compiletime
static const uint8_t scan8 [ 16 * 3 + 3 ] = {
4 + 1 * 8 , 5 + 1 * 8 , 4 + 2 * 8 , 5 + 2 * 8 ,
6 + 1 * 8 , 7 + 1 * 8 , 6 + 2 * 8 , 7 + 2 * 8 ,
4 + 3 * 8 , 5 + 3 * 8 , 4 + 4 * 8 , 5 + 4 * 8 ,
6 + 3 * 8 , 7 + 3 * 8 , 6 + 4 * 8 , 7 + 4 * 8 ,
4 + 6 * 8 , 5 + 6 * 8 , 4 + 7 * 8 , 5 + 7 * 8 ,
6 + 6 * 8 , 7 + 6 * 8 , 6 + 7 * 8 , 7 + 7 * 8 ,
4 + 8 * 8 , 5 + 8 * 8 , 4 + 9 * 8 , 5 + 9 * 8 ,
6 + 8 * 8 , 7 + 8 * 8 , 6 + 9 * 8 , 7 + 9 * 8 ,
4 + 11 * 8 , 5 + 11 * 8 , 4 + 12 * 8 , 5 + 12 * 8 ,
6 + 11 * 8 , 7 + 11 * 8 , 6 + 12 * 8 , 7 + 12 * 8 ,
4 + 13 * 8 , 5 + 13 * 8 , 4 + 14 * 8 , 5 + 14 * 8 ,
6 + 13 * 8 , 7 + 13 * 8 , 6 + 14 * 8 , 7 + 14 * 8 ,
0 + 0 * 8 , 0 + 5 * 8 , 0 + 10 * 8
2010-01-12 07:30:31 +02:00
} ;
2012-05-07 15:13:23 +03:00
static av_always_inline uint32_t pack16to32 ( int a , int b )
{
2010-01-12 07:30:31 +02:00
# if HAVE_BIGENDIAN
2012-05-07 15:13:23 +03:00
return ( b & 0xFFFF ) + ( a < < 16 ) ;
2010-01-12 07:30:31 +02:00
# else
2012-05-07 15:13:23 +03:00
return ( a & 0xFFFF ) + ( b < < 16 ) ;
2010-01-12 07:30:31 +02:00
# endif
}
2012-05-07 15:13:23 +03:00
static av_always_inline uint16_t pack8to16 ( int a , int b )
{
2010-02-24 22:43:06 +02:00
# if HAVE_BIGENDIAN
2012-05-07 15:13:23 +03:00
return ( b & 0xFF ) + ( a < < 8 ) ;
2010-02-24 22:43:06 +02:00
# else
2012-05-07 15:13:23 +03:00
return ( a & 0xFF ) + ( b < < 8 ) ;
2010-02-24 22:43:06 +02:00
# endif
}
2010-01-12 08:01:55 +02:00
/**
2011-12-07 15:03:53 +03:00
* Get the chroma qp .
2010-01-12 08:01:55 +02:00
*/
2012-05-07 15:13:23 +03:00
static av_always_inline int get_chroma_qp ( H264Context * h , int t , int qscale )
{
2010-01-12 08:01:55 +02:00
return h - > pps . chroma_qp_table [ t ] [ qscale ] ;
}
2010-01-13 03:59:19 +02:00
/**
2011-12-07 15:03:53 +03:00
* Get the predicted intra4x4 prediction mode .
2010-01-13 03:59:19 +02:00
*/
2012-05-07 15:13:23 +03:00
static av_always_inline int pred_intra_mode ( H264Context * h , int n )
{
const int index8 = scan8 [ n ] ;
const int left = h - > intra4x4_pred_mode_cache [ index8 - 1 ] ;
const int top = h - > intra4x4_pred_mode_cache [ index8 - 8 ] ;
const int min = FFMIN ( left , top ) ;
2010-01-13 03:59:19 +02:00
2013-02-03 13:10:05 +03:00
tprintf ( h - > avctx , " mode:%d %d min:%d \n " , left , top , min ) ;
2010-01-13 03:59:19 +02:00
2012-05-07 15:13:23 +03:00
if ( min < 0 )
return DC_PRED ;
else
return min ;
2010-01-13 03:59:19 +02:00
}
2012-05-07 15:13:23 +03:00
static av_always_inline void write_back_intra_pred_mode ( H264Context * h )
{
int8_t * i4x4 = h - > intra4x4_pred_mode + h - > mb2br_xy [ h - > mb_xy ] ;
int8_t * i4x4_cache = h - > intra4x4_pred_mode_cache ;
2011-06-29 23:27:36 +03:00
2012-05-07 15:13:23 +03:00
AV_COPY32 ( i4x4 , i4x4_cache + 4 + 8 * 4 ) ;
i4x4 [ 4 ] = i4x4_cache [ 7 + 8 * 3 ] ;
i4x4 [ 5 ] = i4x4_cache [ 7 + 8 * 2 ] ;
i4x4 [ 6 ] = i4x4_cache [ 7 + 8 * 1 ] ;
2011-06-29 23:27:36 +03:00
}
2010-01-13 03:59:19 +02:00
2012-05-07 15:13:23 +03:00
static av_always_inline void write_back_non_zero_count ( H264Context * h )
{
const int mb_xy = h - > mb_xy ;
uint8_t * nnz = h - > non_zero_count [ mb_xy ] ;
2011-06-29 23:27:36 +03:00
uint8_t * nnz_cache = h - > non_zero_count_cache ;
2012-05-07 15:13:23 +03:00
AV_COPY32 ( & nnz [ 0 ] , & nnz_cache [ 4 + 8 * 1 ] ) ;
AV_COPY32 ( & nnz [ 4 ] , & nnz_cache [ 4 + 8 * 2 ] ) ;
AV_COPY32 ( & nnz [ 8 ] , & nnz_cache [ 4 + 8 * 3 ] ) ;
AV_COPY32 ( & nnz [ 12 ] , & nnz_cache [ 4 + 8 * 4 ] ) ;
AV_COPY32 ( & nnz [ 16 ] , & nnz_cache [ 4 + 8 * 6 ] ) ;
AV_COPY32 ( & nnz [ 20 ] , & nnz_cache [ 4 + 8 * 7 ] ) ;
AV_COPY32 ( & nnz [ 32 ] , & nnz_cache [ 4 + 8 * 11 ] ) ;
AV_COPY32 ( & nnz [ 36 ] , & nnz_cache [ 4 + 8 * 12 ] ) ;
2013-02-03 13:10:05 +03:00
if ( ! h - > chroma_y_shift ) {
2012-05-07 15:13:23 +03:00
AV_COPY32 ( & nnz [ 24 ] , & nnz_cache [ 4 + 8 * 8 ] ) ;
AV_COPY32 ( & nnz [ 28 ] , & nnz_cache [ 4 + 8 * 9 ] ) ;
AV_COPY32 ( & nnz [ 40 ] , & nnz_cache [ 4 + 8 * 13 ] ) ;
AV_COPY32 ( & nnz [ 44 ] , & nnz_cache [ 4 + 8 * 14 ] ) ;
2011-06-03 11:12:28 +03:00
}
2010-01-13 03:59:19 +02:00
}
2012-05-07 15:13:23 +03:00
static av_always_inline void write_back_motion_list ( H264Context * h ,
int b_stride ,
int b_xy , int b8_xy ,
int mb_type , int list )
2011-06-29 23:27:36 +03:00
{
2012-11-21 23:34:46 +03:00
int16_t ( * mv_dst ) [ 2 ] = & h - > cur_pic . motion_val [ list ] [ b_xy ] ;
2012-05-07 15:13:23 +03:00
int16_t ( * mv_src ) [ 2 ] = & h - > mv_cache [ list ] [ scan8 [ 0 ] ] ;
AV_COPY128 ( mv_dst + 0 * b_stride , mv_src + 8 * 0 ) ;
AV_COPY128 ( mv_dst + 1 * b_stride , mv_src + 8 * 1 ) ;
AV_COPY128 ( mv_dst + 2 * b_stride , mv_src + 8 * 2 ) ;
AV_COPY128 ( mv_dst + 3 * b_stride , mv_src + 8 * 3 ) ;
2013-03-09 22:37:11 +03:00
if ( CABAC ( h ) ) {
2012-05-07 15:13:23 +03:00
uint8_t ( * mvd_dst ) [ 2 ] = & h - > mvd_table [ list ] [ FMO ? 8 * h - > mb_xy
: h - > mb2br_xy [ h - > mb_xy ] ] ;
uint8_t ( * mvd_src ) [ 2 ] = & h - > mvd_cache [ list ] [ scan8 [ 0 ] ] ;
if ( IS_SKIP ( mb_type ) ) {
2011-06-29 23:27:36 +03:00
AV_ZERO128 ( mvd_dst ) ;
2012-05-07 15:13:23 +03:00
} else {
AV_COPY64 ( mvd_dst , mvd_src + 8 * 3 ) ;
AV_COPY16 ( mvd_dst + 3 + 3 , mvd_src + 3 + 8 * 0 ) ;
AV_COPY16 ( mvd_dst + 3 + 2 , mvd_src + 3 + 8 * 1 ) ;
AV_COPY16 ( mvd_dst + 3 + 1 , mvd_src + 3 + 8 * 2 ) ;
2011-06-29 23:27:36 +03:00
}
}
{
2012-11-21 23:34:46 +03:00
int8_t * ref_index = & h - > cur_pic . ref_index [ list ] [ b8_xy ] ;
2011-06-29 23:27:36 +03:00
int8_t * ref_cache = h - > ref_cache [ list ] ;
2012-05-07 15:13:23 +03:00
ref_index [ 0 + 0 * 2 ] = ref_cache [ scan8 [ 0 ] ] ;
ref_index [ 1 + 0 * 2 ] = ref_cache [ scan8 [ 4 ] ] ;
ref_index [ 0 + 1 * 2 ] = ref_cache [ scan8 [ 8 ] ] ;
ref_index [ 1 + 1 * 2 ] = ref_cache [ scan8 [ 12 ] ] ;
2011-06-03 11:12:28 +03:00
}
2010-01-13 03:59:19 +02:00
}
2012-05-07 15:13:23 +03:00
static av_always_inline void write_back_motion ( H264Context * h , int mb_type )
{
const int b_stride = h - > b_stride ;
2013-02-03 13:10:05 +03:00
const int b_xy = 4 * h - > mb_x + 4 * h - > mb_y * h - > b_stride ; // try mb2b(8)_xy
2012-05-07 15:13:23 +03:00
const int b8_xy = 4 * h - > mb_xy ;
2010-01-13 03:59:19 +02:00
2012-05-07 15:13:23 +03:00
if ( USES_LIST ( mb_type , 0 ) ) {
2013-02-03 13:10:05 +03:00
write_back_motion_list ( h , b_stride , b_xy , b8_xy , mb_type , 0 ) ;
2012-05-07 15:13:23 +03:00
} else {
2012-11-21 23:34:46 +03:00
fill_rectangle ( & h - > cur_pic . ref_index [ 0 ] [ b8_xy ] ,
2011-07-06 21:08:30 +03:00
2 , 2 , 2 , ( uint8_t ) LIST_NOT_USED , 1 ) ;
2011-06-29 23:27:36 +03:00
}
2012-05-07 15:13:23 +03:00
if ( USES_LIST ( mb_type , 1 ) )
2013-02-03 13:10:05 +03:00
write_back_motion_list ( h , b_stride , b_xy , b8_xy , mb_type , 1 ) ;
2010-01-13 03:59:19 +02:00
2013-03-09 22:37:11 +03:00
if ( h - > slice_type_nos = = AV_PICTURE_TYPE_B & & CABAC ( h ) ) {
2012-05-07 15:13:23 +03:00
if ( IS_8X8 ( mb_type ) ) {
uint8_t * direct_table = & h - > direct_table [ 4 * h - > mb_xy ] ;
direct_table [ 1 ] = h - > sub_mb_type [ 1 ] > > 1 ;
direct_table [ 2 ] = h - > sub_mb_type [ 2 ] > > 1 ;
direct_table [ 3 ] = h - > sub_mb_type [ 3 ] > > 1 ;
2010-01-13 03:59:19 +02:00
}
}
}
2012-05-07 15:13:23 +03:00
static av_always_inline int get_dct8x8_allowed ( H264Context * h )
{
if ( h - > sps . direct_8x8_inference_flag )
return ! ( AV_RN64A ( h - > sub_mb_type ) &
( ( MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 ) *
0x0001000100010001ULL ) ) ;
2010-01-13 03:59:19 +02:00
else
2012-05-07 15:13:23 +03:00
return ! ( AV_RN64A ( h - > sub_mb_type ) &
( ( MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2 ) *
0x0001000100010001ULL ) ) ;
2010-01-13 03:59:19 +02:00
}
2014-03-19 18:52:47 +03:00
int ff_h264_field_end ( H264Context * h , int in_setup ) ;
int ff_h264_ref_picture ( H264Context * h , H264Picture * dst , H264Picture * src ) ;
void ff_h264_unref_picture ( H264Context * h , H264Picture * pic ) ;
int ff_h264_context_init ( H264Context * h ) ;
int ff_h264_set_parameter_from_sps ( H264Context * h ) ;
2013-02-03 13:10:05 +03:00
void ff_h264_draw_horiz_band ( H264Context * h , int y , int height ) ;
2013-05-15 01:37:36 +03:00
int ff_init_poc ( H264Context * h , int pic_field_poc [ 2 ] , int * pic_poc ) ;
2013-09-24 12:30:50 +03:00
int ff_pred_weight_table ( H264Context * h ) ;
int ff_set_ref_count ( H264Context * h ) ;
2013-02-03 13:10:05 +03:00
2014-03-19 18:52:47 +03:00
int ff_h264_decode_slice_header ( H264Context * h , H264Context * h0 ) ;
2014-06-19 20:49:26 +03:00
# define SLICE_SINGLETHREAD 1
2014-06-07 21:56:20 +03:00
# define SLICE_SKIPED 2
2014-03-19 18:52:47 +03:00
int ff_h264_execute_decode_slices ( H264Context * h , unsigned context_count ) ;
int ff_h264_update_thread_context ( AVCodecContext * dst ,
const AVCodecContext * src ) ;
void ff_h264_flush_change ( H264Context * h ) ;
void ff_h264_free_tables ( H264Context * h , int free_rbsp ) ;
2014-03-24 03:24:55 +03:00
void ff_h264_set_erpic ( ERPicture * dst , H264Picture * src ) ;
2008-08-31 10:39:47 +03:00
# endif /* AVCODEC_H264_H */