2001-07-22 17:18:56 +03:00
/*
* Generic DCT based hybrid video encoder
2009-01-19 17:46:40 +02:00
* Copyright ( c ) 2000 , 2001 , 2002 Fabrice Bellard
2004-01-10 18:04:55 +02:00
* Copyright ( c ) 2002 - 2004 Michael Niedermayer
2001-07-22 17:18:56 +03:00
*
2006-10-07 18:30:46 +03:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 01:45:33 +03:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 18:30:46 +03:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 17:18:56 +03:00
*
2006-10-07 18:30:46 +03:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 17:18:56 +03:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 01:45:33 +03:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 17:18:56 +03:00
*
2002-05-26 01:45:33 +03:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 18:30:46 +03:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-13 00:43:26 +02:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 17:18:56 +03:00
*/
2003-03-06 13:32:04 +02:00
/**
2010-04-20 17:45:34 +03:00
* @ file
2003-03-06 13:32:04 +02:00
* mpegvideo header .
*/
2005-12-17 20:14:38 +02:00
2008-08-31 10:39:47 +03:00
# ifndef AVCODEC_MPEGVIDEO_H
# define AVCODEC_MPEGVIDEO_H
2002-05-27 19:42:14 +03:00
2011-07-06 21:08:30 +03:00
# include "avcodec.h"
2003-02-10 11:35:32 +02:00
# include "dsputil.h"
2013-02-02 22:42:07 +03:00
# include "error_resilience.h"
2009-04-13 19:20:26 +03:00
# include "get_bits.h"
2013-02-07 15:09:35 +03:00
# include "h264chroma.h"
2013-11-05 10:11:47 +03:00
# include "h263dsp.h"
2013-03-10 23:55:07 +03:00
# include "hpeldsp.h"
2009-04-12 11:35:26 +03:00
# include "put_bits.h"
2006-09-29 22:39:19 +03:00
# include "ratecontrol.h"
2006-11-06 12:43:49 +02:00
# include "parser.h"
2008-03-05 02:06:09 +02:00
# include "mpeg12data.h"
2008-03-05 01:58:12 +02:00
# include "rl.h"
2012-11-21 23:34:46 +03:00
# include "thread.h"
2012-12-15 20:46:02 +03:00
# include "videodsp.h"
2003-02-10 11:35:32 +02:00
2012-02-27 14:12:19 +03:00
# include "libavutil/opt.h"
2012-12-21 19:18:43 +03:00
# include "libavutil/timecode.h"
2012-02-27 14:12:19 +03:00
2005-04-24 20:21:11 +03:00
# define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded
2002-04-22 15:45:22 +03:00
2001-07-22 17:18:56 +03:00
enum OutputFormat {
FMT_MPEG1 ,
2004-05-30 23:37:15 +03:00
FMT_H261 ,
2001-07-22 17:18:56 +03:00
FMT_H263 ,
2005-12-17 20:14:38 +02:00
FMT_MJPEG ,
2001-07-22 17:18:56 +03:00
} ;
# define MPEG_BUF_SIZE (16 * 1024)
2002-09-01 19:52:33 +03:00
# define QMAT_SHIFT_MMX 16
2012-09-20 23:29:03 +03:00
# define QMAT_SHIFT 21
2002-01-27 15:30:18 +02:00
2002-03-22 04:21:17 +02:00
# define MAX_FCODE 7
2013-01-16 07:51:04 +03:00
# define MAX_MV 4096
2002-12-04 12:04:03 +02:00
2012-05-07 21:08:56 +03:00
# define MAX_THREADS 32
2013-01-15 06:58:22 +03:00
# define MAX_PICTURE_COUNT 36
2002-03-22 04:21:17 +02:00
2013-10-27 18:46:01 +03:00
# define MAX_B_FRAMES 16
2002-06-02 15:20:39 +03:00
# define ME_MAP_SIZE 64
# define ME_MAP_SHIFT 3
# define ME_MAP_MV_BITS 11
2005-01-12 02:16:25 +02:00
# define MAX_MB_BYTES (30*16*16*3 / 8 + 120)
2006-01-27 15:19:13 +02:00
# define INPLACE_OFFSET 16
2007-05-05 21:18:51 +03:00
/* Start codes. */
# define SEQ_END_CODE 0x000001b7
# define SEQ_START_CODE 0x000001b3
# define GOP_START_CODE 0x000001b8
# define PICTURE_START_CODE 0x00000100
# define SLICE_MIN_START_CODE 0x00000101
# define SLICE_MAX_START_CODE 0x000001af
# define EXT_START_CODE 0x000001b5
# define USER_START_CODE 0x000001b2
2012-12-12 18:42:05 +03:00
/**
* Value of Picture . reference when Picture is not a reference picture , but
* is held for delayed output .
*/
# define DELAYED_PIC_REF 4
2011-04-18 01:47:35 +03:00
struct MpegEncContext ;
2003-03-06 16:37:37 +02:00
/**
* Picture .
*/
2002-12-04 12:04:03 +02:00
typedef struct Picture {
2011-07-06 21:08:30 +03:00
struct AVFrame f ;
2012-11-21 23:34:46 +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 ;
2013-10-27 18:35:32 +03:00
# if !FF_API_MB_TYPE
# define MB_TYPE_INTRA4x4 0x0001
# define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
# define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific
# define MB_TYPE_16x16 0x0008
# define MB_TYPE_16x8 0x0010
# define MB_TYPE_8x16 0x0020
# define MB_TYPE_8x8 0x0040
# define MB_TYPE_INTERLACED 0x0080
# define MB_TYPE_DIRECT2 0x0100 //FIXME
# define MB_TYPE_ACPRED 0x0200
# define MB_TYPE_GMC 0x0400
# define MB_TYPE_SKIP 0x0800
# define MB_TYPE_P0L0 0x1000
# define MB_TYPE_P1L0 0x2000
# define MB_TYPE_P0L1 0x4000
# define MB_TYPE_P1L1 0x8000
# define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0)
# define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1)
# define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1)
# define MB_TYPE_QUANT 0x00010000
# define MB_TYPE_CBP 0x00020000
# endif
2012-11-21 23:34:46 +03:00
AVBufferRef * mbskip_table_buf ;
uint8_t * mbskip_table ;
AVBufferRef * ref_index_buf [ 2 ] ;
int8_t * ref_index [ 2 ] ;
AVBufferRef * mb_var_buf ;
uint16_t * mb_var ; ///< Table for MB variances
AVBufferRef * mc_mb_var_buf ;
uint16_t * mc_mb_var ; ///< Table for motion compensated MB variances
2013-03-29 01:46:13 +03:00
int alloc_mb_width ; ///< mb_width used to allocate tables
int alloc_mb_height ; ///< mb_height used to allocate tables
2012-11-21 23:34:46 +03:00
AVBufferRef * mb_mean_buf ;
uint8_t * mb_mean ; ///< Table for MB luminance
AVBufferRef * hwaccel_priv_buf ;
/**
* hardware accelerator private data
*/
void * hwaccel_picture_private ;
2002-12-04 12:04:03 +02:00
2007-12-02 16:06:28 +02:00
# define MB_TYPE_INTRA MB_TYPE_INTRA4x4 //default mb_type if there is just one type
2003-04-04 17:42:28 +03:00
# define IS_INTRA4x4(a) ((a)&MB_TYPE_INTRA4x4)
# define IS_INTRA16x16(a) ((a)&MB_TYPE_INTRA16x16)
2003-04-10 16:18:38 +03:00
# define IS_PCM(a) ((a)&MB_TYPE_INTRA_PCM)
# define IS_INTRA(a) ((a)&7)
2003-04-04 17:42:28 +03:00
# define IS_INTER(a) ((a)&(MB_TYPE_16x16|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8))
2003-04-10 16:18:38 +03:00
# define IS_SKIP(a) ((a)&MB_TYPE_SKIP)
2003-04-04 17:42:28 +03:00
# define IS_INTRA_PCM(a) ((a)&MB_TYPE_INTRA_PCM)
# define IS_INTERLACED(a) ((a)&MB_TYPE_INTERLACED)
# define IS_DIRECT(a) ((a)&MB_TYPE_DIRECT2)
2003-04-10 16:18:38 +03:00
# define IS_GMC(a) ((a)&MB_TYPE_GMC)
2003-04-04 17:42:28 +03:00
# define IS_16X16(a) ((a)&MB_TYPE_16x16)
# define IS_16X8(a) ((a)&MB_TYPE_16x8)
# define IS_8X16(a) ((a)&MB_TYPE_8x16)
# define IS_8X8(a) ((a)&MB_TYPE_8x8)
# define IS_SUB_8X8(a) ((a)&MB_TYPE_16x16) //note reused
# define IS_SUB_8X4(a) ((a)&MB_TYPE_16x8) //note reused
# define IS_SUB_4X8(a) ((a)&MB_TYPE_8x16) //note reused
# define IS_SUB_4X4(a) ((a)&MB_TYPE_8x8) //note reused
2003-04-10 16:18:38 +03:00
# define IS_ACPRED(a) ((a)&MB_TYPE_ACPRED)
# define IS_QUANT(a) ((a)&MB_TYPE_QUANT)
2003-04-04 17:42:28 +03:00
# define IS_DIR(a, part, list) ((a) & (MB_TYPE_P0L0<<((part)+2*(list))))
2007-06-12 12:29:25 +03:00
# define USES_LIST(a, list) ((a) & ((MB_TYPE_P0L0|MB_TYPE_P1L0)<<(2*(list)))) ///< does this mb use listX, note does not work if subMBs
2003-12-04 20:34:47 +02:00
# define HAS_CBP(a) ((a)&MB_TYPE_CBP)
2003-04-04 17:42:28 +03:00
int field_poc [ 2 ] ; ///< h264 top/bottom POC
int poc ; ///< h264 frame POC
2007-10-02 17:25:47 +03:00
int frame_num ; ///< h264 frame_num (raw frame_num from slice header)
2009-06-24 15:10:20 +03:00
int mmco_reset ; ///< h264 MMCO_RESET set this 1. Reordering code must not mix pictures before and after MMCO_RESET.
2007-10-02 17:25:47 +03:00
int pic_id ; /**< h264 pic_num (short -> no wrap version of pic_num,
pic_num & max_pic_num ; long - > long_pic_num ) */
2003-04-04 17:42:28 +03:00
int long_ref ; ///< 1->long term reference 0->short term reference
2011-10-02 01:47:54 +03:00
int ref_poc [ 2 ] [ 2 ] [ 32 ] ; ///< h264 POCs of the frames/fields used as reference (FIXME need per slice)
2008-08-03 02:13:27 +03:00
int ref_count [ 2 ] [ 2 ] ; ///< number of entries in ref_poc (FIXME need per slice)
2008-09-22 05:32:22 +03:00
int mbaff ; ///< h264 1 -> MBAFF frame 0-> not MBAFF
2012-03-13 01:30:13 +03:00
int field_picture ; ///< whether or not the picture was encoded in separate fields
2003-04-04 17:42:28 +03:00
2005-12-17 20:14:38 +02:00
int mb_var_sum ; ///< sum of MB variance for current frame
int mc_mb_var_sum ; ///< motion compensated MB variance for current frame
2012-11-21 23:34:46 +03:00
2013-05-23 15:43:42 +03:00
int b_frame_score ;
2012-09-05 21:40:12 +03:00
int needs_realloc ; ///< Picture needs to be reallocated (eg due to a frame size change)
2012-11-21 23:34:46 +03:00
int reference ;
int shared ;
2013-10-11 19:51:50 +03:00
int recovered ; ///< Picture at IDR or recovery point + recovery count
2013-05-01 00:51:30 +03:00
int crop ;
int crop_left ;
int crop_top ;
2002-12-04 12:04:03 +02:00
} Picture ;
2003-03-06 16:37:37 +02:00
/**
* Motion estimation context .
*/
2002-12-28 01:51:46 +02:00
typedef struct MotionEstContext {
2004-05-11 04:38:46 +03:00
AVCodecContext * avctx ;
2005-12-17 20:14:38 +02:00
int skip ; ///< set if ME is skipped for the current MB
2007-06-12 12:29:25 +03:00
int co_located_mv [ 4 ] [ 2 ] ; ///< mv from last P-frame for direct mode ME
2002-12-28 01:51:46 +02:00
int direct_basis_mv [ 4 ] [ 2 ] ;
2007-06-12 12:29:25 +03:00
uint8_t * scratchpad ; ///< data area for the ME algo, so that the ME does not need to malloc/free
2004-04-22 06:31:29 +03:00
uint8_t * best_mb ;
uint8_t * temp_mb [ 2 ] ;
uint8_t * temp ;
int best_bits ;
2005-12-17 20:14:38 +02:00
uint32_t * map ; ///< map to avoid duplicate evaluations
uint32_t * score_map ; ///< map to store the scores
2011-10-09 22:18:34 +03:00
unsigned map_generation ;
2003-01-05 17:57:10 +02:00
int pre_penalty_factor ;
2011-06-23 23:41:54 +03:00
int penalty_factor ; /**< an estimate of the bits required to
2007-04-01 01:39:43 +03:00
code a given mv value , e . g . ( 1 , 0 ) takes
more bits than ( 0 , 0 ) . We have to
estimate whether any reduction in
residual is worth the extra bits . */
2002-12-28 01:51:46 +02:00
int sub_penalty_factor ;
2003-01-19 19:55:13 +02:00
int mb_penalty_factor ;
2004-04-22 06:31:29 +03:00
int flags ;
int sub_flags ;
int mb_flags ;
2005-12-17 20:14:38 +02:00
int pre_pass ; ///< = 1 for the pre pass
2003-01-05 17:57:10 +02:00
int dia_size ;
2003-12-30 18:07:57 +02:00
int xmin ;
int xmax ;
int ymin ;
int ymax ;
2004-04-22 06:31:29 +03:00
int pred_x ;
int pred_y ;
uint8_t * src [ 4 ] [ 4 ] ;
uint8_t * ref [ 4 ] [ 4 ] ;
int stride ;
int uvstride ;
2004-05-11 04:38:46 +03:00
/* temp variables for picture complexity calculation */
int mc_mb_var_sum_temp ;
int mb_var_sum_temp ;
int scene_change_score ;
2004-04-22 06:31:29 +03:00
/* cmp, chroma_cmp;*/
op_pixels_func ( * hpel_put ) [ 4 ] ;
op_pixels_func ( * hpel_avg ) [ 4 ] ;
qpel_mc_func ( * qpel_put ) [ 16 ] ;
qpel_mc_func ( * qpel_avg ) [ 16 ] ;
2005-12-17 20:14:38 +02:00
uint8_t ( * mv_penalty ) [ MAX_MV * 2 + 1 ] ; ///< amount of bits needed to encode a MV
2004-04-22 06:31:29 +03:00
uint8_t * current_mv_penalty ;
2002-12-28 01:51:46 +02:00
int ( * sub_motion_search ) ( struct MpegEncContext * s ,
2005-12-22 03:10:11 +02:00
int * mx_ptr , int * my_ptr , int dmin ,
2004-04-22 06:31:29 +03:00
int src_index , int ref_index ,
int size , int h ) ;
2002-12-28 01:51:46 +02:00
} MotionEstContext ;
2003-03-06 16:37:37 +02:00
/**
* MpegEncContext .
*/
2001-07-22 17:18:56 +03:00
typedef struct MpegEncContext {
2011-08-27 09:26:14 +03:00
AVClass * class ;
2001-08-15 16:12:23 +03:00
struct AVCodecContext * avctx ;
2001-07-22 17:18:56 +03:00
/* the following parameters must be initialized before encoding */
2005-12-17 20:14:38 +02:00
int width , height ; ///< picture size. must be a multiple of 16
2001-07-22 17:18:56 +03:00
int gop_size ;
2005-12-17 20:14:38 +02:00
int intra_only ; ///< if true, only intra pictures are generated
int bit_rate ; ///< wanted bit rate
enum OutputFormat out_format ; ///< output format
int h263_pred ; ///< use mpeg4/h263 ac/dc predictions
2009-02-22 20:13:40 +02:00
int pb_frame ; ///< PB frame mode (0 = none, 1 = base, 2 = improved)
2002-04-27 15:30:26 +03:00
/* the following codec id fields are deprecated in favor of codec_id */
2005-12-17 20:14:38 +02:00
int h263_plus ; ///< h263 plus headers
int h263_flv ; ///< use flv h263 header
2012-08-05 12:11:04 +03:00
enum AVCodecID codec_id ; /* see AV_CODEC_ID_xxx */
2005-12-17 20:14:38 +02:00
int fixed_qscale ; ///< fixed qscale if non zero
int encoding ; ///< true if we are encoding (vs decoding)
int flags ; ///< AVCodecContext.flags (HQ, MV4, ...)
2004-01-22 21:48:28 +02:00
int flags2 ; ///< AVCodecContext.flags2
2005-12-17 20:14:38 +02:00
int max_b_frames ; ///< max number of b-frames for encoding
2002-06-02 15:20:39 +03:00
int luma_elim_threshold ;
int chroma_elim_threshold ;
2005-12-17 20:14:38 +02:00
int strict_std_compliance ; ///< strictly follow the std (MPEG4, ...)
int workaround_bugs ; ///< workaround bugs in encoders which cannot be detected automatically
2006-11-07 11:46:57 +02:00
int codec_tag ; ///< internal codec_tag upper case converted from avctx codec_tag
int stream_codec_tag ; ///< internal stream_codec_tag upper case converted from avctx stream_codec_tag
2001-07-22 17:18:56 +03:00
/* the following fields are managed internally by the encoder */
/* sequence parameters */
int context_initialized ;
2007-06-12 12:29:25 +03:00
int input_picture_number ; ///< used to set pic->display_picture_number, should not be used for/by anything else
int coded_picture_number ; ///< used to set pic->coded_picture_number, should not be used for/by anything else
2003-12-30 00:25:08 +02:00
int picture_number ; //FIXME remove, unclear definition
2005-12-17 20:14:38 +02:00
int picture_in_gop_number ; ///< 0-> first pic in gop, ...
int mb_width , mb_height ; ///< number of MBs horizontally & vertically
2005-06-17 18:02:53 +03:00
int mb_stride ; ///< mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11
int b8_stride ; ///< 2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
int b4_stride ; ///< 4*mb_width+1 used for some 4x4 block arrays to allow simple addressing
int h_edge_pos , v_edge_pos ; ///< horizontal / vertical position of the right/bottom edge (pixel replication)
2005-12-17 20:14:38 +02:00
int mb_num ; ///< number of MBs of a picture
2013-09-28 03:13:59 +03:00
ptrdiff_t linesize ; ///< line size, in bytes, may be different from width
ptrdiff_t uvlinesize ; ///< line size, for chroma in bytes, may be different from width
2005-12-17 20:14:38 +02:00
Picture * picture ; ///< main picture buffer
2003-10-22 18:36:46 +03:00
Picture * * input_picture ; ///< next pictures on display order for encoding
Picture * * reordered_input_picture ; ///< pointer to the next pictures in codedorder for encoding
2005-12-17 20:14:38 +02:00
2011-01-29 19:14:29 +02:00
int y_dc_scale , c_dc_scale ;
int ac_pred ;
int block_last_index [ 12 ] ; ///< last non zero coefficient in block
int h263_aic ; ///< Advanded INTRA Coding (AIC)
/* scantables */
ScanTable inter_scantable ; ///< if inter == intra then intra should be used to reduce tha cache usage
ScanTable intra_scantable ;
ScanTable intra_h_scantable ;
ScanTable intra_v_scantable ;
/* WARNING: changes above this line require updates to hardcoded
* offsets used in asm . */
2013-09-10 13:31:46 +03:00
int64_t user_specified_pts ; ///< last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
2012-02-10 12:30:05 +03:00
/**
* pts difference between the first and second input frame , used for
* calculating dts of the first frame when there ' s a delay */
int64_t dts_delta ;
/**
* reordered pts to be used as dts for the next output frame when there ' s
* a delay */
int64_t reordered_pts ;
2011-08-01 17:18:13 +03:00
2011-01-29 19:14:29 +02:00
/** bit output */
PutBitContext pb ;
2004-02-13 19:54:10 +02:00
int start_mb_y ; ///< start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
int end_mb_y ; ///< end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
struct MpegEncContext * thread_context [ MAX_THREADS ] ;
2012-01-01 22:24:24 +03:00
int slice_context_count ; ///< number of used thread_contexts
2005-12-17 20:14:38 +02:00
/**
2003-03-16 22:22:22 +02:00
* copy of the previous picture structure .
* note , linesize & data , might not match the previous picture ( for field pictures )
*/
2005-12-17 20:14:38 +02:00
Picture last_picture ;
/**
2003-03-16 22:22:22 +02:00
* copy of the next picture structure .
* note , linesize & data , might not match the next picture ( for field pictures )
*/
Picture next_picture ;
2005-12-17 20:14:38 +02:00
/**
2003-03-16 22:22:22 +02:00
* copy of the source picture structure for encoding .
* note , linesize & data , might not match the source picture ( for field pictures )
*/
Picture new_picture ;
2005-12-17 20:14:38 +02:00
/**
2003-03-16 22:22:22 +02:00
* copy of the current picture structure .
* note , linesize & data , might not match the current picture ( for field pictures )
*/
2005-12-17 20:14:38 +02:00
Picture current_picture ; ///< buffer to store the decompressed current picture
2003-03-16 22:22:22 +02:00
Picture * last_picture_ptr ; ///< pointer to the previous picture.
2005-12-17 20:14:38 +02:00
Picture * next_picture_ptr ; ///< pointer to the next picture (for bidir pred)
2003-03-16 22:22:22 +02:00
Picture * current_picture_ptr ; ///< pointer to the current picture
2005-12-17 20:14:38 +02:00
int last_dc [ 3 ] ; ///< last DC values for MPEG1
2006-09-28 01:13:44 +03:00
int16_t * dc_val_base ;
int16_t * dc_val [ 3 ] ; ///< used for mpeg4 DC prediction, all 3 arrays must be continuous
2005-12-17 20:14:38 +02:00
const uint8_t * y_dc_scale_table ; ///< qscale -> y_dc_scale table
const uint8_t * c_dc_scale_table ; ///< qscale -> c_dc_scale table
2003-12-01 17:23:14 +02:00
const uint8_t * chroma_qscale_table ; ///< qscale -> chroma_qscale (h263)
2004-04-16 04:01:45 +03:00
uint8_t * coded_block_base ;
2003-03-06 16:37:37 +02:00
uint8_t * coded_block ; ///< used for coded block pattern prediction (msmpeg4v3, wmv1)
2004-04-16 04:01:45 +03:00
int16_t ( * ac_val_base ) [ 16 ] ;
2013-08-12 20:40:29 +03:00
int16_t ( * ac_val [ 3 ] ) [ 16 ] ; ///< used for mpeg4 AC prediction, all 3 arrays must be continuous
2005-12-17 20:14:38 +02:00
int mb_skipped ; ///< MUST BE SET only during DECODING
uint8_t * mbskip_table ; /**< used to avoid copy if macroblock skipped (for black regions for example)
2002-04-17 07:32:12 +03:00
and used for b - frame encoding & decoding ( contains skip table of next P Frame ) */
2005-12-17 20:14:38 +02:00
uint8_t * mbintra_table ; ///< used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
uint8_t * cbp_table ; ///< used to store cbp, ac_pred for partitioned decoding
uint8_t * pred_dir_table ; ///< used to store pred_dir for partitioned decoding
2011-10-03 18:38:03 +03:00
uint8_t * edge_emu_buffer ; ///< temporary buffer for if MVs point to out-of-frame data
2005-06-17 18:02:53 +03:00
uint8_t * rd_scratchpad ; ///< scratchpad for rate distortion mb decision
2004-02-13 19:54:10 +02:00
uint8_t * obmc_scratchpad ;
uint8_t * b_scratchpad ; ///< scratchpad used for writing into write only buffers
2001-07-22 17:18:56 +03:00
2005-12-17 20:14:38 +02:00
int qscale ; ///< QP
int chroma_qscale ; ///< chroma QP
2006-10-28 19:11:25 +03:00
unsigned int lambda ; ///< lagrange multipler used in rate distortion
unsigned int lambda2 ; ///< (lambda*lambda) >> FF_LAMBDA_SHIFT
2003-10-07 14:32:40 +03:00
int * lambda_table ;
2005-12-17 20:14:38 +02:00
int adaptive_quant ; ///< use adaptive quantization
int dquant ; ///< qscale difference to prev qscale
2011-10-24 02:04:14 +03:00
int closed_gop ; ///< MPEG1/2 GOP is closed
2011-04-28 02:40:44 +03:00
int pict_type ; ///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
2012-11-02 18:25:03 +03:00
int vbv_delay ;
2004-04-17 16:36:21 +03:00
int last_pict_type ; //FIXME removes
2005-12-17 20:14:38 +02:00
int last_non_b_pict_type ; ///< used for mpeg4 gmc b-frames & ratecontrol
2012-12-07 12:25:27 +03:00
int droppable ;
2001-07-22 17:18:56 +03:00
int frame_rate_index ;
2012-10-04 16:25:30 +03:00
AVRational mpeg2_frame_rate_ext ;
2005-12-29 17:46:23 +02:00
int last_lambda_for [ 5 ] ; ///< last lambda for a specific pict type
2006-12-23 05:05:36 +02:00
int skipdct ; ///< skip dct and code zero residual
2004-03-01 16:55:21 +02:00
2001-07-22 17:18:56 +03:00
/* motion compensation */
2005-12-17 20:14:38 +02:00
int unrestricted_mv ; ///< mv can point outside of the coded picture
int h263_long_vectors ; ///< use horrible h263v1 long vector mode
2003-03-06 16:37:37 +02:00
2005-06-17 18:02:53 +03:00
DSPContext dsp ; ///< pointers for accelerated dsp functions
2013-02-07 15:09:35 +03:00
H264ChromaContext h264chroma ;
2013-03-10 23:55:07 +03:00
HpelDSPContext hdsp ;
2012-12-15 20:46:02 +03:00
VideoDSPContext vdsp ;
2013-11-05 10:11:47 +03:00
H263DSPContext h263dsp ;
2005-12-17 20:14:38 +02:00
int f_code ; ///< forward MV resolution
int b_code ; ///< backward MV resolution for B Frames (mpeg4)
2003-04-10 16:18:38 +03:00
int16_t ( * p_mv_table_base ) [ 2 ] ;
int16_t ( * b_forw_mv_table_base ) [ 2 ] ;
int16_t ( * b_back_mv_table_base ) [ 2 ] ;
2005-12-17 20:14:38 +02:00
int16_t ( * b_bidir_forw_mv_table_base ) [ 2 ] ;
int16_t ( * b_bidir_back_mv_table_base ) [ 2 ] ;
2003-04-10 16:18:38 +03:00
int16_t ( * b_direct_mv_table_base ) [ 2 ] ;
2003-12-30 18:07:57 +02:00
int16_t ( * p_field_mv_table_base [ 2 ] [ 2 ] ) [ 2 ] ;
int16_t ( * b_field_mv_table_base [ 2 ] [ 2 ] [ 2 ] ) [ 2 ] ;
2005-12-17 20:14:38 +02:00
int16_t ( * p_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) p-frame encoding
int16_t ( * b_forw_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) forward mode b-frame encoding
int16_t ( * b_back_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) backward mode b-frame encoding
int16_t ( * b_bidir_forw_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) bidir mode b-frame encoding
int16_t ( * b_bidir_back_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) bidir mode b-frame encoding
int16_t ( * b_direct_mv_table ) [ 2 ] ; ///< MV table (1MV per MB) direct mode b-frame encoding
2003-12-30 18:07:57 +02:00
int16_t ( * p_field_mv_table [ 2 ] [ 2 ] ) [ 2 ] ; ///< MV table (2MV per MB) interlaced p-frame encoding
int16_t ( * b_field_mv_table [ 2 ] [ 2 ] [ 2 ] ) [ 2 ] ; ///< MV table (4MV per MB) interlaced b-frame encoding
uint8_t ( * p_field_select_table [ 2 ] ) ;
uint8_t ( * b_field_select_table [ 2 ] [ 2 ] ) ;
2005-12-17 20:14:38 +02:00
int me_method ; ///< ME algorithm
2001-07-22 17:18:56 +03:00
int mv_dir ;
2007-08-02 01:12:52 +03:00
# define MV_DIR_FORWARD 1
# define MV_DIR_BACKWARD 2
2003-03-06 16:37:37 +02:00
# define MV_DIRECT 4 ///< bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4)
2001-07-22 17:18:56 +03:00
int mv_type ;
2005-12-17 20:14:38 +02:00
# define MV_TYPE_16X16 0 ///< 1 vector for the whole mb
# define MV_TYPE_8X8 1 ///< 4 vectors (h263, mpeg4 4MV)
# define MV_TYPE_16X8 2 ///< 2 vectors, one per 16x8 block
# define MV_TYPE_FIELD 3 ///< 2 vectors, one per field
# define MV_TYPE_DMV 4 ///< 2 vectors, special mpeg2 Dual Prime Vectors
/**motion vectors for a macroblock
2001-07-22 17:18:56 +03:00
first coordinate : 0 = forward 1 = backward
second " : depend on type
third " : 0 = x, 1 = y
*/
int mv [ 2 ] [ 4 ] [ 2 ] ;
int field_select [ 2 ] [ 2 ] ;
2005-12-17 20:14:38 +02:00
int last_mv [ 2 ] [ 2 ] [ 2 ] ; ///< last MV, used for MV prediction in MPEG1 & B-frame MPEG4
uint8_t * fcode_tab ; ///< smallest fcode needed for each MV
2006-04-03 10:52:24 +03:00
int16_t direct_scale_mv [ 2 ] [ 64 ] ; ///< precomputed to avoid divisions in ff_mpeg4_set_direct_mv
2005-12-17 20:14:38 +02:00
2002-12-28 01:51:46 +02:00
MotionEstContext me ;
2001-07-22 17:18:56 +03:00
2005-12-17 20:14:38 +02:00
int no_rounding ; /**< apply no rounding to motion compensation (MPEG4, msmpeg4, ...)
2007-04-07 17:09:20 +03:00
for b - frames rounding mode is always 0 */
2001-07-22 17:18:56 +03:00
/* macroblock layer */
int mb_x , mb_y ;
2003-03-30 22:26:01 +03:00
int mb_skip_run ;
2001-07-22 17:18:56 +03:00
int mb_intra ;
2003-12-30 18:07:57 +02:00
uint16_t * mb_type ; ///< Table for candidate MB types for encoding
# define CANDIDATE_MB_TYPE_INTRA 0x01
# define CANDIDATE_MB_TYPE_INTER 0x02
# define CANDIDATE_MB_TYPE_INTER4V 0x04
2005-04-24 20:21:11 +03:00
# define CANDIDATE_MB_TYPE_SKIPPED 0x08
2003-04-10 16:18:38 +03:00
//#define MB_TYPE_GMC 0x10
2002-06-02 15:20:39 +03:00
2003-12-30 18:07:57 +02:00
# define CANDIDATE_MB_TYPE_DIRECT 0x10
# define CANDIDATE_MB_TYPE_FORWARD 0x20
# define CANDIDATE_MB_TYPE_BACKWARD 0x40
# define CANDIDATE_MB_TYPE_BIDIR 0x80
# define CANDIDATE_MB_TYPE_INTER_I 0x100
# define CANDIDATE_MB_TYPE_FORWARD_I 0x200
# define CANDIDATE_MB_TYPE_BACKWARD_I 0x400
# define CANDIDATE_MB_TYPE_BIDIR_I 0x800
2002-03-15 16:57:17 +02:00
2006-12-21 17:20:02 +02:00
# define CANDIDATE_MB_TYPE_DIRECT0 0x1000
2003-03-06 16:37:37 +02:00
int block_index [ 6 ] ; ///< index to current MB in block based arrays with edges
2002-03-15 16:57:17 +02:00
int block_wrap [ 6 ] ;
2003-07-29 05:09:12 +03:00
uint8_t * dest [ 3 ] ;
2005-12-17 20:14:38 +02:00
2003-04-10 16:18:38 +03:00
int * mb_index2xy ; ///< mb_index -> mb_x + mb_y*mb_stride
2002-03-15 16:57:17 +02:00
2003-03-06 16:37:37 +02:00
/** matrix transmitted in the bitstream */
2003-02-11 18:35:48 +02:00
uint16_t intra_matrix [ 64 ] ;
uint16_t chroma_intra_matrix [ 64 ] ;
uint16_t inter_matrix [ 64 ] ;
uint16_t chroma_inter_matrix [ 64 ] ;
2003-03-22 14:09:02 +02:00
# define QUANT_BIAS_SHIFT 8
2005-12-17 20:14:38 +02:00
int intra_quant_bias ; ///< bias for the quantizer
int inter_quant_bias ; ///< bias for the quantizer
int min_qcoeff ; ///< minimum encodable coefficient
int max_qcoeff ; ///< maximum encodable coefficient
int ac_esc_length ; ///< num of bits needed to encode the longest esc
2002-12-31 19:23:56 +02:00
uint8_t * intra_ac_vlc_length ;
uint8_t * intra_ac_vlc_last_length ;
uint8_t * inter_ac_vlc_length ;
uint8_t * inter_ac_vlc_last_length ;
2003-01-19 19:55:13 +02:00
uint8_t * luma_dc_vlc_length ;
2003-01-01 02:42:18 +02:00
# define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level))
2002-12-31 19:23:56 +02:00
2012-11-08 00:44:27 +03:00
int coded_score [ 12 ] ;
2003-10-01 01:18:43 +03:00
2003-03-06 16:37:37 +02:00
/** precomputed matrix (combine qscale and DCT renorm) */
2003-10-22 13:59:39 +03:00
int ( * q_intra_matrix ) [ 64 ] ;
2011-09-25 07:46:39 +03:00
int ( * q_chroma_intra_matrix ) [ 64 ] ;
2003-10-22 13:59:39 +03:00
int ( * q_inter_matrix ) [ 64 ] ;
2003-10-22 14:23:39 +03:00
/** identical to the above but for MMX & these are not permutated, second 64 entries are bias*/
uint16_t ( * q_intra_matrix16 ) [ 2 ] [ 64 ] ;
2011-09-25 07:46:39 +03:00
uint16_t ( * q_chroma_intra_matrix16 ) [ 2 ] [ 64 ] ;
2003-10-22 14:23:39 +03:00
uint16_t ( * q_inter_matrix16 ) [ 2 ] [ 64 ] ;
2005-12-17 20:14:38 +02:00
2003-11-03 01:19:47 +02:00
/* noise reduction */
int ( * dct_error_sum ) [ 64 ] ;
int dct_count [ 2 ] ;
uint16_t ( * dct_offset ) [ 64 ] ;
2001-07-22 17:18:56 +03:00
2003-03-06 16:37:37 +02:00
void * opaque ; ///< private data for the user
2001-07-22 17:18:56 +03:00
/* bit rate control */
2003-02-11 18:35:48 +02:00
int64_t total_bits ;
2005-12-17 20:14:38 +02:00
int frame_bits ; ///< bits used for the current frame
2012-09-11 18:20:08 +03:00
int stuffing_bits ; ///< bits used for stuffing
2006-10-05 22:27:18 +03:00
int next_lambda ; ///< next lambda used for retrying to encode a frame
2003-03-06 16:37:37 +02:00
RateControlContext rc_context ; ///< contains stuff only accessed in ratecontrol.c
2002-03-17 18:31:38 +02:00
2002-03-23 19:43:30 +02:00
/* statistics, used for 2-pass encoding */
int mv_bits ;
int header_bits ;
int i_tex_bits ;
int p_tex_bits ;
int i_count ;
2002-09-12 15:26:09 +03:00
int f_count ;
int b_count ;
2002-03-23 19:43:30 +02:00
int skip_count ;
2003-03-06 16:37:37 +02:00
int misc_bits ; ///< cbp, mb_type
int last_bits ; ///< temp var used for calculating the above vars
2005-12-17 20:14:38 +02:00
2002-06-02 15:20:39 +03:00
/* error concealment / resync */
2005-12-17 20:14:38 +02:00
int resync_mb_x ; ///< x position of last resync marker
int resync_mb_y ; ///< y position of last resync marker
GetBitContext last_resync_gb ; ///< used to search for the next resync marker
2003-03-06 16:37:37 +02:00
int mb_num_left ; ///< number of MBs left in this video packet (for partitioned Slices only)
2005-12-17 20:14:38 +02:00
int next_p_frame_damaged ; ///< set if the next p frame is damaged, to avoid showing trashed b frames
2011-12-07 16:51:36 +03:00
int err_recognition ;
2005-12-17 20:14:38 +02:00
2002-11-08 20:35:39 +02:00
ParseContext parse_context ;
2002-03-23 19:43:30 +02:00
2001-11-12 07:19:55 +02:00
/* H.263 specific */
2001-11-19 04:13:14 +02:00
int gob_index ;
2003-11-29 10:37:51 +02:00
int obmc ; ///< overlapped block motion compensation
2012-02-28 00:23:45 +03:00
int mb_info ; ///< interval for outputting info about mb offsets as side data
int prev_mb_info , last_mb_info ;
uint8_t * mb_info_ptr ;
int mb_info_size ;
2013-08-24 19:44:24 +03:00
int ehc_mode ;
2005-12-17 20:14:38 +02:00
2001-08-31 09:21:27 +03:00
/* H.263+ specific */
2005-12-17 20:14:38 +02:00
int umvplus ; ///< == H263+ && unrestricted_mv
2003-12-07 03:33:45 +02:00
int h263_aic_dir ; ///< AIC direction: 0 = left, 1 = top
int h263_slice_structured ;
2003-11-29 10:37:51 +02:00
int alt_inter_vlc ; ///< alternative inter vlc
2003-11-30 16:35:35 +02:00
int modified_quant ;
2005-12-17 20:14:38 +02:00
int loop_filter ;
2004-03-11 00:11:49 +02:00
int custom_pcf ;
2005-12-17 20:14:38 +02:00
2001-07-22 17:18:56 +03:00
/* mpeg4 specific */
2013-11-26 13:23:16 +03:00
///< number of bits to represent the fractional part of time (encoder only)
int time_increment_bits ;
2002-04-17 07:32:12 +03:00
int last_time_base ;
2005-12-17 20:14:38 +02:00
int time_base ; ///< time in seconds of last I,P,S Frame
int64_t time ; ///< time of current frame
2003-02-11 18:35:48 +02:00
int64_t last_non_b_time ;
2005-12-17 20:14:38 +02:00
uint16_t pp_time ; ///< time distance between the last 2 p,s,i frames
uint16_t pb_time ; ///< time distance between the last b and p,s,i frame
2003-02-11 18:35:48 +02:00
uint16_t pp_field_time ;
2005-12-17 20:14:38 +02:00
uint16_t pb_field_time ; ///< like above, just for interlaced
2002-03-09 15:01:16 +02:00
int real_sprite_warping_points ;
2005-12-17 20:14:38 +02:00
int sprite_offset [ 2 ] [ 2 ] ; ///< sprite offset[isChroma][isMVY]
int sprite_delta [ 2 ] [ 2 ] ; ///< sprite_delta [isY][isMVY]
2002-03-07 15:27:15 +02:00
int mcsel ;
2001-08-14 00:48:05 +03:00
int quant_precision ;
2005-12-17 20:14:38 +02:00
int quarter_sample ; ///< 1->qpel, 0->half pel ME/MC
2003-04-04 17:42:28 +03:00
int aspect_ratio_info ; //FIXME remove
2002-03-05 15:58:13 +02:00
int sprite_warping_accuracy ;
2005-12-17 20:14:38 +02:00
int data_partitioning ; ///< data partitioning flag from header
int partitioned_frame ; ///< is current frame partitioned
int low_delay ; ///< no reordering needed / has no b-frames
2002-04-22 22:04:28 +03:00
int vo_type ;
2005-12-17 20:14:38 +02:00
int vol_control_parameters ; ///< does the stream contain the low_delay flag, used to workaround buggy encoders
PutBitContext tex_pb ; ///< used for data partitioned VOPs
PutBitContext pb2 ; ///< used for data partitioned VOPs
2002-08-02 23:27:46 +03:00
int mpeg_quant ;
2005-12-17 20:14:38 +02:00
int padding_bug_score ; ///< used to detect the VERY common padding bug in MPEG4
2002-03-09 15:01:16 +02:00
/* divx specific, used to workaround (many) bugs in divx5 */
2003-03-20 19:52:30 +02:00
int divx_packed ;
2003-02-11 18:35:48 +02:00
uint8_t * bitstream_buffer ; //Divx 5.01 puts several frames in a single one, this is used to reorder them
2002-04-22 15:45:22 +03:00
int bitstream_buffer_size ;
2006-01-26 00:10:13 +02:00
unsigned int allocated_bitstream_buffer_size ;
2005-12-17 20:14:38 +02:00
2001-07-22 17:18:56 +03:00
/* RV10 specific */
2005-12-17 20:14:38 +02:00
int rv10_version ; ///< RV10 version: 0 or 3
2001-07-22 17:18:56 +03:00
int rv10_first_dc_coded [ 3 ] ;
2009-12-02 00:30:03 +02:00
int orig_width , orig_height ;
2005-12-17 20:14:38 +02:00
2001-07-22 17:18:56 +03:00
/* MJPEG specific */
struct MJpegContext * mjpeg_ctx ;
2012-06-14 17:26:15 +03:00
int esc_pos ;
2001-07-22 17:18:56 +03:00
/* MSMPEG4 specific */
int mv_table_index ;
int rl_table_index ;
int rl_chroma_table_index ;
int dc_table_index ;
int use_skip_mb_code ;
2005-12-17 20:14:38 +02:00
int slice_height ; ///< in macroblocks
int first_slice_line ; ///< used in mpeg4 too to handle resync markers
2002-01-16 00:22:41 +02:00
int flipflop_rounding ;
2003-03-06 16:37:37 +02:00
int msmpeg4_version ; ///< 0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
2002-06-18 03:50:20 +03:00
int per_mb_rl_table ;
int esc3_level_length ;
int esc3_run_length ;
2003-03-06 16:37:37 +02:00
/** [mb_intra][isChroma][level][run][last] */
2002-09-11 10:26:43 +03:00
int ( * ac_stats ) [ 2 ] [ MAX_LEVEL + 1 ] [ MAX_RUN + 1 ] [ 2 ] ;
2002-07-07 11:34:46 +03:00
int inter_intra_pred ;
2002-12-28 01:51:46 +02:00
int mspel ;
2002-06-18 03:50:20 +03:00
2001-07-22 17:18:56 +03:00
/* decompression specific */
GetBitContext gb ;
2002-12-04 12:04:03 +02:00
/* Mpeg1 specific */
2005-12-17 20:14:38 +02:00
int gop_picture_number ; ///< index of the first picture of a GOP based on fake_pic_num & mpeg1 specific
int last_mv_dir ; ///< last mv_dir, used for b frame encoding
uint8_t * vbv_delay_ptr ; ///< pointer to vbv_delay in the bitstream
2009-03-02 07:41:55 +02:00
/* MPEG-2-specific - I wished not to have to support this mess. */
2001-07-22 17:18:56 +03:00
int progressive_sequence ;
int mpeg_f_code [ 2 ] [ 2 ] ;
int picture_structure ;
/* picture type */
# define PICT_TOP_FIELD 1
# define PICT_BOTTOM_FIELD 2
# define PICT_FRAME 3
int intra_dc_precision ;
int frame_pred_frame_dct ;
int top_field_first ;
int concealment_motion_vectors ;
int q_scale_type ;
int intra_vlc_format ;
int alternate_scan ;
int repeat_first_field ;
int chroma_420_type ;
2004-03-01 16:55:21 +02:00
int chroma_format ;
# define CHROMA_420 1
# define CHROMA_422 2
# define CHROMA_444 3
2004-06-11 10:59:12 +03:00
int chroma_x_shift ; //depend on pix_format, that depend on chroma_format
int chroma_y_shift ;
2004-03-01 16:55:21 +02:00
2001-07-22 17:18:56 +03:00
int progressive_frame ;
2011-10-24 02:34:38 +03:00
int full_pel [ 2 ] ;
2001-07-22 17:18:56 +03:00
int interlaced_dct ;
2003-08-22 17:59:04 +03:00
int first_field ; ///< is 1 for the first field of a field picture 0 otherwise
2011-08-27 09:34:05 +03:00
int drop_frame_timecode ; ///< timecode is in drop frame format.
2011-08-27 11:16:14 +03:00
int scan_offset ; ///< reserve space for SVCD scan offset user data.
2003-12-07 03:33:45 +02:00
2001-11-19 04:13:14 +02:00
/* RTP specific */
2003-08-26 01:54:53 +03:00
int rtp_mode ;
2005-12-17 20:14:38 +02:00
2012-01-16 16:45:46 +03:00
char * tc_opt_str ; ///< timecode option string
AVTimecode tc ; ///< timecode context
2011-07-06 15:44:59 +03:00
2003-02-11 18:35:48 +02:00
uint8_t * ptr_lastgob ;
2009-03-02 07:41:55 +02:00
int swap_uv ; //vcr2 codec is an MPEG-2 variant with U and V swapped
2013-12-14 22:29:15 +03:00
int pack_pblocks ; //xvmc needs to keep blocks without gaps.
2013-01-20 03:02:29 +03:00
int16_t ( * pblocks [ 12 ] ) [ 64 ] ;
2005-12-17 20:14:38 +02:00
2013-01-20 03:02:29 +03:00
int16_t ( * block ) [ 64 ] ; ///< points to one of the following blocks
2013-01-23 19:44:56 +03:00
int16_t ( * blocks ) [ 12 ] [ 64 ] ; // for HQ mode we need to keep the best block
2013-01-20 03:02:29 +03:00
int ( * decode_mb ) ( struct MpegEncContext * s , int16_t block [ 6 ] [ 64 ] ) ; // used by some codecs to avoid a switch()
2002-10-13 16:16:04 +03:00
# define SLICE_OK 0
# define SLICE_ERROR -1
2003-08-22 17:59:04 +03:00
# define SLICE_END -2 ///<end marker found
# define SLICE_NOEND -3 ///<no end marker or error found but mb count exceeded
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_mpeg1_intra ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_mpeg1_inter ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_mpeg2_intra ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_mpeg2_inter ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_h263_intra ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_h263_inter ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_h261_intra ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2005-12-17 20:14:38 +02:00
void ( * dct_unquantize_h261_inter ) ( struct MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2003-12-14 04:57:00 +02:00
void ( * dct_unquantize_intra ) ( struct MpegEncContext * s , // unquantizer to use (mpeg4 can use both)
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
2003-12-14 04:57:00 +02:00
void ( * dct_unquantize_inter ) ( struct MpegEncContext * s , // unquantizer to use (mpeg4 can use both)
2013-01-20 03:02:29 +03:00
int16_t * block /*align 16*/ , int n , int qscale ) ;
int ( * dct_quantize ) ( struct MpegEncContext * s , int16_t * block /*align 16*/ , int n , int qscale , int * overflow ) ;
int ( * fast_dct_quantize ) ( struct MpegEncContext * s , int16_t * block /*align 16*/ , int n , int qscale , int * overflow ) ;
void ( * denoise_dct ) ( struct MpegEncContext * s , int16_t * block ) ;
2012-02-27 14:12:19 +03:00
int mpv_flags ; ///< flags set by private options
2012-02-27 22:06:23 +03:00
int quantizer_noise_shaping ;
2012-06-24 21:19:24 +03:00
/* temp buffers for rate control */
float * cplx_tab , * bits_tab ;
2012-09-18 16:48:14 +03:00
/* flag to indicate a reinitialization is required, e.g. after
* a frame size change */
int context_reinit ;
2013-02-02 22:42:07 +03:00
ERContext er ;
2013-10-27 15:51:16 +03:00
int error_rate ;
2013-11-09 12:14:46 +03:00
/* temporary frames used by b_frame_strategy = 2 */
AVFrame * tmp_frames [ MAX_B_FRAMES + 2 ] ;
2001-07-22 17:18:56 +03:00
} MpegEncContext ;
2013-01-31 22:24:06 +03:00
# define REBASE_PICTURE(pic, new_ctx, old_ctx) \
( ( pic & & pic > = old_ctx - > picture & & \
2012-11-21 23:34:46 +03:00
pic < old_ctx - > picture + MAX_PICTURE_COUNT ) ? \
2013-01-31 22:24:06 +03:00
& new_ctx - > picture [ pic - old_ctx - > picture ] : NULL )
2002-10-13 16:16:04 +03:00
2012-02-27 14:12:19 +03:00
/* mpegvideo_enc common options */
# define FF_MPV_FLAG_SKIP_RD 0x0001
2012-02-27 14:23:19 +03:00
# define FF_MPV_FLAG_STRICT_GOP 0x0002
2012-02-27 14:23:19 +03:00
# define FF_MPV_FLAG_QP_RD 0x0004
2012-02-27 14:23:19 +03:00
# define FF_MPV_FLAG_CBP_RD 0x0008
2012-02-27 14:12:19 +03:00
# define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
# define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
# define FF_MPV_COMMON_OPTS \
2012-08-31 12:52:18 +03:00
{ " mpv_flags " , " Flags common for all mpegvideo-based encoders. " , FF_MPV_OFFSET ( mpv_flags ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , INT_MIN , INT_MAX , FF_MPV_OPT_FLAGS , " mpv_flags " } , \
2012-08-31 12:45:52 +03:00
{ " skip_rd " , " RD optimal MB level residual skipping " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MPV_FLAG_SKIP_RD } , 0 , 0 , FF_MPV_OPT_FLAGS , " mpv_flags " } , \
{ " strict_gop " , " Strictly enforce gop size " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MPV_FLAG_STRICT_GOP } , 0 , 0 , FF_MPV_OPT_FLAGS , " mpv_flags " } , \
{ " qp_rd " , " Use rate distortion optimization for qp selection " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MPV_FLAG_QP_RD } , 0 , 0 , FF_MPV_OPT_FLAGS , " mpv_flags " } , \
{ " cbp_rd " , " use rate distortion optimization for CBP " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MPV_FLAG_CBP_RD } , 0 , 0 , FF_MPV_OPT_FLAGS , " mpv_flags " } , \
2012-02-27 21:09:49 +03:00
{ " luma_elim_threshold " , " single coefficient elimination threshold for luminance (negative values also consider dc coefficient) " , \
2012-08-31 13:22:31 +03:00
FF_MPV_OFFSET ( luma_elim_threshold ) , AV_OPT_TYPE_INT , { . i64 = 0 } , INT_MIN , INT_MAX , FF_MPV_OPT_FLAGS } , \
2012-02-27 21:09:49 +03:00
{ " chroma_elim_threshold " , " single coefficient elimination threshold for chrominance (negative values also consider dc coefficient) " , \
2012-08-31 13:22:31 +03:00
FF_MPV_OFFSET ( chroma_elim_threshold ) , AV_OPT_TYPE_INT , { . i64 = 0 } , INT_MIN , INT_MAX , FF_MPV_OPT_FLAGS } , \
2013-10-27 15:51:16 +03:00
{ " quantizer_noise_shaping " , NULL , FF_MPV_OFFSET ( quantizer_noise_shaping ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , FF_MPV_OPT_FLAGS } , \
{ " error_rate " , " Simulate errors in the bitstream to test error concealment. " , \
FF_MPV_OFFSET ( error_rate ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , FF_MPV_OPT_FLAGS } ,
2012-02-27 14:12:19 +03:00
extern const AVOption ff_mpv_generic_options [ ] ;
# define FF_MPV_GENERIC_CLASS(name) \
static const AVClass name # # _class = { \
. class_name = # name " encoder " , \
. item_name = av_default_item_name , \
. option = ff_mpv_generic_options , \
. version = LIBAVUTIL_VERSION_INT , \
} ;
2012-08-04 02:50:21 +03:00
/**
* Set the given MpegEncContext to common defaults ( same for encoding
* and decoding ) . The changed fields will not depend upon the prior
* state of the MpegEncContext .
*/
void ff_MPV_common_defaults ( MpegEncContext * s ) ;
2012-02-15 15:10:33 +03:00
void ff_MPV_decode_defaults ( MpegEncContext * s ) ;
int ff_MPV_common_init ( MpegEncContext * s ) ;
2012-09-05 21:40:12 +03:00
int ff_MPV_common_frame_size_change ( MpegEncContext * s ) ;
2012-02-15 15:10:33 +03:00
void ff_MPV_common_end ( MpegEncContext * s ) ;
2013-01-20 03:02:29 +03:00
void ff_MPV_decode_mb ( MpegEncContext * s , int16_t block [ 12 ] [ 64 ] ) ;
2012-02-15 15:10:33 +03:00
int ff_MPV_frame_start ( MpegEncContext * s , AVCodecContext * avctx ) ;
void ff_MPV_frame_end ( MpegEncContext * s ) ;
int ff_MPV_encode_init ( AVCodecContext * avctx ) ;
int ff_MPV_encode_end ( AVCodecContext * avctx ) ;
2012-02-10 12:30:05 +03:00
int ff_MPV_encode_picture ( AVCodecContext * avctx , AVPacket * pkt ,
2012-03-16 00:04:21 +03:00
AVFrame * frame , int * got_packet ) ;
2012-09-25 19:04:36 +03:00
void ff_dct_encode_init_x86 ( MpegEncContext * s ) ;
2012-08-13 14:13:57 +03:00
void ff_MPV_common_init_x86 ( MpegEncContext * s ) ;
2012-02-15 15:10:33 +03:00
void ff_MPV_common_init_axp ( MpegEncContext * s ) ;
void ff_MPV_common_init_arm ( MpegEncContext * s ) ;
void ff_MPV_common_init_bfin ( MpegEncContext * s ) ;
2013-04-14 15:47:30 +03:00
void ff_MPV_common_init_ppc ( MpegEncContext * s ) ;
2002-06-02 15:20:39 +03:00
void ff_clean_intra_table_entries ( MpegEncContext * s ) ;
2013-02-03 16:26:34 +03:00
void ff_draw_horiz_band ( AVCodecContext * avctx , DSPContext * dsp , Picture * cur ,
Picture * last , int y , int h , int picture_structure ,
int first_field , int draw_edges , int low_delay ,
int v_edge_pos , int h_edge_pos ) ;
void ff_mpeg_draw_horiz_band ( MpegEncContext * s , int y , int h ) ;
2003-07-17 15:29:07 +03:00
void ff_mpeg_flush ( AVCodecContext * avctx ) ;
2013-03-12 12:51:03 +03:00
2013-03-12 13:23:07 +03:00
void ff_print_debug_info ( MpegEncContext * s , Picture * p , AVFrame * pict ) ;
2013-03-12 13:06:35 +03:00
void ff_print_debug_info2 ( AVCodecContext * avctx , Picture * p , AVFrame * pict , uint8_t * mbskip_table ,
2013-03-12 13:23:07 +03:00
int * low_delay ,
2013-03-12 12:51:03 +03:00
int mb_width , int mb_height , int mb_stride , int quarter_sample ) ;
2013-03-15 16:33:24 +03:00
int ff_mpv_export_qp_table ( MpegEncContext * s , AVFrame * f , Picture * p , int qp_type ) ;
2006-09-27 22:47:39 +03:00
void ff_write_quant_matrix ( PutBitContext * pb , uint16_t * matrix ) ;
2003-10-30 18:58:49 +02:00
int ff_find_unused_picture ( MpegEncContext * s , int shared ) ;
2013-01-20 03:02:29 +03:00
void ff_denoise_dct ( MpegEncContext * s , int16_t * block ) ;
2012-11-26 00:42:07 +03:00
int ff_update_duplicate_context ( MpegEncContext * dst , MpegEncContext * src ) ;
2012-02-15 15:10:33 +03:00
int ff_MPV_lowest_referenced_row ( MpegEncContext * s , int dir ) ;
void ff_MPV_report_decode_progress ( MpegEncContext * s ) ;
2011-03-22 23:36:57 +02:00
int ff_mpeg_update_thread_context ( AVCodecContext * dst , const AVCodecContext * src ) ;
2010-03-07 00:36:52 +02:00
void ff_set_qscale ( MpegEncContext * s , int qscale ) ;
2002-12-17 13:25:29 +02:00
2013-02-02 22:42:07 +03:00
void ff_mpeg_er_frame_start ( MpegEncContext * s ) ;
2003-03-20 03:00:57 +02:00
2007-10-08 12:09:19 +03:00
int ff_dct_common_init ( MpegEncContext * s ) ;
2012-09-25 19:04:36 +03:00
int ff_dct_encode_init ( MpegEncContext * s ) ;
2007-10-08 12:14:46 +03:00
void ff_convert_matrix ( DSPContext * dsp , int ( * qmat ) [ 64 ] , uint16_t ( * qmat16 ) [ 2 ] [ 64 ] ,
const uint16_t * quant_matrix , int bias , int qmin , int qmax , int intra ) ;
2013-01-20 03:02:29 +03:00
int ff_dct_quantize_c ( MpegEncContext * s , int16_t * block , int n , int qscale , int * overflow ) ;
2003-03-20 03:00:57 +02:00
2003-07-29 05:09:12 +03:00
void ff_init_block_index ( MpegEncContext * s ) ;
2002-10-13 16:16:04 +03:00
2012-08-04 02:50:21 +03:00
void ff_MPV_motion ( MpegEncContext * s ,
uint8_t * dest_y , uint8_t * dest_cb ,
uint8_t * dest_cr , int dir ,
uint8_t * * ref_picture ,
op_pixels_func ( * pix_op ) [ 4 ] ,
qpel_mc_func ( * qpix_op ) [ 16 ] ) ;
2009-05-27 22:55:35 +03:00
/**
2011-12-07 15:03:53 +03:00
* Allocate a Picture .
* The pixels are allocated / set by calling get_buffer ( ) if shared = 0.
2009-05-27 22:55:35 +03:00
*/
int ff_alloc_picture ( MpegEncContext * s , Picture * pic , int shared ) ;
2012-10-06 13:10:34 +03:00
extern const enum AVPixelFormat ff_pixfmt_list_420 [ ] ;
2009-02-24 20:27:52 +02:00
2013-02-07 23:04:32 +03:00
/**
* permute block according to permuatation .
* @ param last last non zero element in scantable order
*/
void ff_block_permute ( int16_t * block , uint8_t * permutation , const uint8_t * scantable , int last ) ;
2002-10-13 16:16:04 +03:00
static inline void ff_update_block_index ( MpegEncContext * s ) {
2012-04-22 22:37:54 +03:00
const int block_size = 8 > > s - > avctx - > lowres ;
2004-09-26 02:18:58 +03:00
2002-10-13 16:16:04 +03:00
s - > block_index [ 0 ] + = 2 ;
s - > block_index [ 1 ] + = 2 ;
s - > block_index [ 2 ] + = 2 ;
s - > block_index [ 3 ] + = 2 ;
s - > block_index [ 4 ] + + ;
s - > block_index [ 5 ] + + ;
2004-09-26 02:18:58 +03:00
s - > dest [ 0 ] + = 2 * block_size ;
s - > dest [ 1 ] + = block_size ;
s - > dest [ 2 ] + = block_size ;
2002-10-13 16:16:04 +03:00
}
2003-04-02 12:57:34 +03:00
static inline int get_bits_diff ( MpegEncContext * s ) {
2004-02-06 17:27:31 +02:00
const int bits = put_bits_count ( & s - > pb ) ;
2003-04-02 12:57:34 +03:00
const int last = s - > last_bits ;
s - > last_bits = bits ;
return bits - last ;
}
2002-10-13 16:16:04 +03:00
2007-07-12 00:04:53 +03:00
static inline int ff_h263_round_chroma ( int x ) {
static const uint8_t h263_chroma_roundtab [ 16 ] = {
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
2007-07-12 01:05:25 +03:00
0 , 0 , 0 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 ,
2007-07-12 00:04:53 +03:00
} ;
2007-07-12 01:05:25 +03:00
return h263_chroma_roundtab [ x & 0xf ] + ( x > > 3 ) ;
2007-07-12 00:04:53 +03:00
}
2001-07-22 17:18:56 +03:00
/* motion_est.c */
2002-04-17 07:32:12 +03:00
void ff_estimate_p_frame_motion ( MpegEncContext * s ,
int mb_x , int mb_y ) ;
void ff_estimate_b_frame_motion ( MpegEncContext * s ,
int mb_x , int mb_y ) ;
int ff_get_best_fcode ( MpegEncContext * s , int16_t ( * mv_table ) [ 2 ] , int type ) ;
void ff_fix_long_p_mvs ( MpegEncContext * s ) ;
2003-12-30 18:07:57 +02:00
void ff_fix_long_mvs ( MpegEncContext * s , uint8_t * field_select_table , int field_select ,
int16_t ( * mv_table ) [ 2 ] , int f_code , int type , int truncate ) ;
2008-05-28 04:54:09 +03:00
int ff_init_me ( MpegEncContext * s ) ;
2003-01-02 03:29:35 +02:00
int ff_pre_estimate_p_frame_motion ( MpegEncContext * s , int mb_x , int mb_y ) ;
2008-02-03 19:54:30 +02:00
int ff_epzs_motion_search ( MpegEncContext * s , int * mx_ptr , int * my_ptr ,
2005-12-17 20:14:38 +02:00
int P [ 10 ] [ 2 ] , int src_index , int ref_index , int16_t ( * last_mv ) [ 2 ] ,
int ref_mv_scale , int size , int h ) ;
2008-02-03 19:54:30 +02:00
int ff_get_mb_score ( MpegEncContext * s , int mx , int my , int src_index ,
2004-08-26 23:04:54 +03:00
int ref_index , int size , int h , int add_rate ) ;
2002-10-13 16:16:04 +03:00
2001-07-22 17:18:56 +03:00
/* mpeg12.c */
2005-06-02 00:19:00 +03:00
extern const uint8_t ff_mpeg1_dc_scale_table [ 128 ] ;
2010-03-16 00:49:46 +02:00
extern const uint8_t * const ff_mpeg2_dc_scale_table [ 4 ] ;
2001-07-22 17:18:56 +03:00
2012-02-15 13:38:52 +03:00
void ff_mpeg1_encode_picture_header ( MpegEncContext * s , int picture_number ) ;
void ff_mpeg1_encode_mb ( MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t block [ 6 ] [ 64 ] ,
2012-02-15 13:38:52 +03:00
int motion_x , int motion_y ) ;
2002-06-18 03:50:20 +03:00
void ff_mpeg1_encode_init ( MpegEncContext * s ) ;
2003-03-30 22:26:01 +03:00
void ff_mpeg1_encode_slice_header ( MpegEncContext * s ) ;
2001-07-22 17:18:56 +03:00
2005-06-02 00:19:00 +03:00
extern const uint8_t ff_aic_dc_scale_table [ 32 ] ;
2003-12-01 17:23:14 +02:00
extern const uint8_t ff_h263_chroma_qscale_table [ 32 ] ;
2003-11-30 16:35:35 +02:00
2001-07-22 17:18:56 +03:00
/* rv10.c */
2012-02-15 14:54:05 +03:00
void ff_rv10_encode_picture_header ( MpegEncContext * s , int picture_number ) ;
int ff_rv_decode_dc ( MpegEncContext * s , int n ) ;
void ff_rv20_encode_picture_header ( MpegEncContext * s , int picture_number ) ;
2001-07-22 17:18:56 +03:00
2002-10-13 16:16:04 +03:00
2001-07-22 17:18:56 +03:00
/* msmpeg4.c */
2012-02-15 14:05:06 +03:00
void ff_msmpeg4_encode_picture_header ( MpegEncContext * s , int picture_number ) ;
void ff_msmpeg4_encode_ext_header ( MpegEncContext * s ) ;
void ff_msmpeg4_encode_mb ( MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t block [ 6 ] [ 64 ] ,
2012-02-15 14:05:06 +03:00
int motion_x , int motion_y ) ;
int ff_msmpeg4_decode_picture_header ( MpegEncContext * s ) ;
int ff_msmpeg4_decode_ext_header ( MpegEncContext * s , int buf_size ) ;
2010-01-08 21:40:10 +02:00
int ff_msmpeg4_decode_init ( AVCodecContext * avctx ) ;
2002-06-18 03:50:20 +03:00
void ff_msmpeg4_encode_init ( MpegEncContext * s ) ;
2002-12-28 01:51:46 +02:00
int ff_wmv2_decode_picture_header ( MpegEncContext * s ) ;
2003-09-10 01:59:16 +03:00
int ff_wmv2_decode_secondary_picture_header ( MpegEncContext * s ) ;
2013-01-20 03:02:29 +03:00
void ff_wmv2_add_mb ( MpegEncContext * s , int16_t block [ 6 ] [ 64 ] , uint8_t * dest_y , uint8_t * dest_cb , uint8_t * dest_cr ) ;
2002-12-28 01:51:46 +02:00
void ff_mspel_motion ( MpegEncContext * s ,
2003-02-11 18:35:48 +02:00
uint8_t * dest_y , uint8_t * dest_cb , uint8_t * dest_cr ,
uint8_t * * ref_picture , op_pixels_func ( * pix_op ) [ 4 ] ,
2002-12-28 01:51:46 +02:00
int motion_x , int motion_y , int h ) ;
int ff_wmv2_encode_picture_header ( MpegEncContext * s , int picture_number ) ;
2005-12-17 20:14:38 +02:00
void ff_wmv2_encode_mb ( MpegEncContext * s ,
2013-01-20 03:02:29 +03:00
int16_t block [ 6 ] [ 64 ] ,
2002-12-28 01:51:46 +02:00
int motion_x , int motion_y ) ;
2001-07-22 17:18:56 +03:00
2012-11-21 23:34:46 +03:00
int ff_mpeg_ref_picture ( MpegEncContext * s , Picture * dst , Picture * src ) ;
void ff_mpeg_unref_picture ( MpegEncContext * s , Picture * picture ) ;
2013-11-30 13:50:09 +03:00
void ff_free_picture_tables ( Picture * pic ) ;
2012-11-21 23:34:46 +03:00
2013-03-12 05:20:18 +03:00
2008-08-31 10:39:47 +03:00
# endif /* AVCODEC_MPEGVIDEO_H */