28 #ifndef AVCODEC_MPEGVIDEO_H
29 #define AVCODEC_MPEGVIDEO_H
62 #define MAX_THREADS 32
64 #define MAX_B_FRAMES 16
67 #define SEQ_END_CODE 0x000001b7
68 #define SEQ_START_CODE 0x000001b3
69 #define GOP_START_CODE 0x000001b8
70 #define PICTURE_START_CODE 0x00000100
71 #define SLICE_MIN_START_CODE 0x00000101
72 #define SLICE_MAX_START_CODE 0x000001af
73 #define EXT_START_CODE 0x000001b5
74 #define USER_START_CODE 0x000001b2
75 #define SLICE_START_CODE 0x000001b7
262 #define MV_DIR_FORWARD 1
263 #define MV_DIR_BACKWARD 2
266 #define MV_TYPE_16X16 0
267 #define MV_TYPE_8X8 1
268 #define MV_TYPE_16X8 2
269 #define MV_TYPE_FIELD 3
270 #define MV_TYPE_DMV 4
318 #define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level))
372 #if FF_API_MPV_RC_STRATEGY
479 #define VIDEO_FORMAT_COMPONENT 0
480 #define VIDEO_FORMAT_PAL 1
481 #define VIDEO_FORMAT_NTSC 2
482 #define VIDEO_FORMAT_SECAM 3
483 #define VIDEO_FORMAT_MAC 4
484 #define VIDEO_FORMAT_UNSPECIFIED 5
522 #define SLICE_ERROR -1
524 #define SLICE_NOEND -3
593 #define FF_MPV_FLAG_SKIP_RD 0x0001
594 #define FF_MPV_FLAG_STRICT_GOP 0x0002
595 #define FF_MPV_FLAG_QP_RD 0x0004
596 #define FF_MPV_FLAG_CBP_RD 0x0008
597 #define FF_MPV_FLAG_NAQ 0x0010
598 #define FF_MPV_FLAG_MV0 0x0020
600 #define FF_MPV_OPT_CMP_FUNC \
601 { "sad", "Sum of absolute differences, fast", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
602 { "sse", "Sum of squared errors", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
603 { "satd", "Sum of absolute Hadamard transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SATD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
604 { "dct", "Sum of absolute DCT transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
605 { "psnr", "Sum of squared quantization errors, low quality", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_PSNR }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
606 { "bit", "Number of bits needed for the block", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_BIT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
607 { "rd", "Rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_RD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
608 { "zero", "Zero", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_ZERO }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
609 { "vsad", "Sum of absolute vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
610 { "vsse", "Sum of squared vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
611 { "nsse", "Noise preserving sum of squared differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_NSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
612 { "dct264", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT264 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
613 { "dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
614 { "chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_CHROMA }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
615 { "msad", "Sum of absolute differences, median predicted", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_MEDIAN_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }
617 #ifndef FF_MPV_OFFSET
618 #define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
620 #if FF_API_MPV_RC_STRATEGY
621 #define FF_MPV_RC_STRATEGY_OPTS \
622 {"rc_strategy", "ratecontrol method", FF_MPV_OFFSET(rc_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED, "rc_strategy" }, \
623 { "ffmpeg", "deprecated, does nothing", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED, "rc_strategy" }, \
624 { "xvid", "deprecated, does nothing", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED, "rc_strategy" },
626 #define FF_MPV_RC_STRATEGY_OPTS
628 #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
629 #define FF_MPV_COMMON_OPTS \
630 FF_MPV_OPT_CMP_FUNC, \
631 { "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" },\
632 { "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" },\
633 { "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" },\
634 { "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" },\
635 { "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" },\
636 { "naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
637 { "mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_MV0 }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
638 { "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\
639 FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
640 { "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\
641 FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
642 { "quantizer_noise_shaping", NULL, FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\
643 { "error_rate", "Simulate errors in the bitstream to test error concealment.", \
644 FF_MPV_OFFSET(error_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\
645 {"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", \
646 FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS}, \
647 {"rc_qmod_amp", "experimental quantizer modulation", FF_MPV_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
648 {"rc_qmod_freq", "experimental quantizer modulation", FF_MPV_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS}, \
649 {"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions " \
650 "defined in the section 'Expression Evaluation', the following functions are available: " \
651 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv " \
652 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.", \
653 FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING, .flags = FF_MPV_OPT_FLAGS }, \
654 {"rc_init_cplx", "initial complexity for 1-pass encoding", FF_MPV_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
655 {"rc_buf_aggressivity", "currently useless", FF_MPV_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
656 {"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
657 {"lmin", "minimum Lagrange factor (VBR)", FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 = 2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \
658 {"lmax", "maximum Lagrange factor (VBR)", FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \
659 {"ibias", "intra quant bias", FF_MPV_OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
660 {"pbias", "inter quant bias", FF_MPV_OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
661 {"motion_est", "motion estimation algorithm", FF_MPV_OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, FF_MPV_OPT_FLAGS, "motion_est" }, \
662 { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
663 { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
664 { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
665 { "force_duplicated_matrix", "Always write luma and chroma matrix for mjpeg, useful for rtp streaming.", FF_MPV_OFFSET(force_duplicated_matrix), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS }, \
666 {"b_strategy", "Strategy to choose between I/P/B-frames", FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
667 {"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1", FF_MPV_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
668 {"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS }, \
669 {"skip_threshold", "Frame skip threshold", FF_MPV_OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
670 {"skip_factor", "Frame skip factor", FF_MPV_OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
671 {"skip_exp", "Frame skip exponent", FF_MPV_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
672 {"skip_cmp", "Frame skip compare function", FF_MPV_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
673 {"sc_threshold", "Scene change threshold", FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
674 {"noise_reduction", "Noise reduction", FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
675 {"mpeg_quant", "Use MPEG quantizers instead of H.263", FF_MPV_OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS }, \
676 {"ps", "RTP payload size in bytes", FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
677 {"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
678 {"mepre", "pre motion estimation", FF_MPV_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
679 {"intra_penalty", "Penalty for intra blocks in block decision", FF_MPV_OFFSET(intra_penalty), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX/2, FF_MPV_OPT_FLAGS }, \
680 {"a53cc", "Use A53 Closed Captions (if available)", FF_MPV_OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FF_MPV_OPT_FLAGS }, \
681 FF_MPV_RC_STRATEGY_OPTS
737 const uint16_t *quant_matrix,
int bias,
int qmin,
int qmax,
int intra);
740 const uint8_t *scantable,
int last);
751 const int bytes_per_pixel = 1 + (
s->avctx->bits_per_raw_sample > 8);
752 const int block_size= (8*bytes_per_pixel) >>
s->avctx->lowres;
754 s->block_index[0]+=2;
755 s->block_index[1]+=2;
756 s->block_index[2]+=2;
757 s->block_index[3]+=2;
760 s->dest[0]+= 2*block_size;
761 s->dest[1]+= (2 >>
s->chroma_x_shift) * block_size;
762 s->dest[2]+= (2 >>
s->chroma_x_shift) * block_size;
767 const int last=
s->last_bits;
Libavcodec external API header.
bitstream reader API header.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVCodecID
Identify the syntax and semantics of the bitstream.
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
static const int32_t qmat16[MAT_SIZE]
common internal API header
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
void ff_dct_encode_init_x86(MpegEncContext *s)
void ff_mpv_common_end(MpegEncContext *s)
void ff_convert_matrix(MpegEncContext *s, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
const AVOption ff_mpv_generic_options[]
void ff_mpv_common_init_neon(MpegEncContext *s)
void ff_mpv_frame_end(MpegEncContext *s)
int ff_mpv_encode_end(AVCodecContext *avctx)
void ff_mpv_common_init_axp(MpegEncContext *s)
void ff_mpv_common_init_x86(MpegEncContext *s)
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static int get_bits_diff(MpegEncContext *s)
int ff_dct_encode_init(MpegEncContext *s)
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
void ff_mpv_common_init_mips(MpegEncContext *s)
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])
void ff_mpeg_flush(AVCodecContext *avctx)
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
void ff_mpv_encode_init_x86(MpegEncContext *s)
int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
void ff_mpv_common_init_ppc(MpegEncContext *s)
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
static int mpeg_get_qscale(MpegEncContext *s)
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
void ff_mpv_common_init_arm(MpegEncContext *s)
void ff_init_block_index(MpegEncContext *s)
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
void ff_mpv_idct_init(MpegEncContext *s)
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
int ff_mpv_common_frame_size_change(MpegEncContext *s)
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
void ff_mpv_report_decode_progress(MpegEncContext *s)
int ff_mpv_encode_init(AVCodecContext *avctx)
static void ff_update_block_index(MpegEncContext *s)
const uint8_t ff_mpeg2_non_linear_qscale[32]
static int put_bits_count(PutBitContext *s)
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
typedef void(RENAME(mix_any_func_type))
Describe the class of an AVClass context structure.
main external API structure.
This structure describes decoded (raw) audio or video data.
This structure stores compressed data.
Rational number (pair of numerator and denominator).
Holds JPEG frame data and Huffman table data.
Motion estimation context.
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
int intra_only
if true, only intra pictures are generated
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
struct MpegEncContext * thread_context[MAX_THREADS]
int16_t(*[2][2][2] b_field_mv_table_base)[2]
int block_index[6]
index to current MB in block based arrays with edges
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode B-frame encoding.
void(* denoise_dct)(struct MpegEncContext *s, int16_t *block)
int partitioned_frame
is current frame partitioned
int h263_plus
H.263+ headers.
float rc_buffer_aggressivity
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
uint16_t(* q_chroma_intra_matrix16)[2][64]
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
int force_duplicated_matrix
Force duplication of mjpeg matrices, useful for rtp streaming.
uint8_t * pred_dir_table
used to store pred_dir for partitioned decoding
int last_non_b_pict_type
used for MPEG-4 gmc B-frames & ratecontrol
int mb_height
number of MBs horizontally & vertically
int16_t(* block)[64]
points to one of the following blocks
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode B-frame encoding.
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
int drop_frame_timecode
timecode is in drop frame format.
char * tc_opt_str
timecode option string
int obmc
overlapped block motion compensation
int16_t(* b_bidir_forw_mv_table_base)[2]
int(* q_inter_matrix)[64]
PutBitContext tex_pb
used for data partitioned VOPs
int64_t reordered_pts
reordered pts to be used as dts for the next output frame when there's a delay
int rc_strategy
deprecated
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
int intra_quant_bias
bias for the quantizer
Picture ** input_picture
next pictures on display order for encoding
int fixed_qscale
fixed qscale if non zero
int16_t * dc_val[3]
used for MPEG-4 DC prediction, all 3 arrays must be continuous
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
uint8_t *[2] p_field_select_table
unsigned int lambda
Lagrange multiplier used in rate distortion.
int(* decode_mb)(struct MpegEncContext *s, int16_t block[12][64])
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
int input_picture_number
used to set pic->display_picture_number, should not be used for/by anything else
uint8_t * intra_chroma_ac_vlc_last_length
int scenechange_threshold
ParseContext parse_context
int64_t bit_rate
wanted bit rate
int16_t(* ac_val_base)[16]
int data_partitioning
data partitioning flag from header
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
AVFrame * tmp_frames[MAX_B_FRAMES+2]
int adaptive_quant
use adaptive quantization
int me_penalty_compensation
ptrdiff_t linesize
line size, in bytes, may be different from width
uint16_t inter_matrix[64]
Picture * picture
main picture buffer
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
int rv10_first_dc_coded[3]
int ac_esc_length
num of bits needed to encode the longest esc
int padding_bug_score
used to detect the VERY common padding bug in MPEG-4
int h263_long_vectors
use horrible H.263v1 long vector mode
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
int f_code
forward MV resolution
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
uint8_t * intra_chroma_ac_vlc_length
uint16_t pb_time
time distance between the last b and p,s,i frame
int64_t user_specified_pts
last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
int(* ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2]
[mb_intra][isChroma][level][run][last]
int slice_context_count
number of used thread_contexts
int h263_pred
use MPEG-4/H.263 ac/dc predictions
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int16_t(* p_mv_table_base)[2]
const uint8_t * fcode_tab
smallest fcode needed for each MV
ScanTable intra_h_scantable
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
uint8_t * bitstream_buffer
int scan_offset
reserve space for SVCD scan offset user data.
int rv10_version
RV10 version: 0 or 3.
struct MJpegContext * mjpeg_ctx
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
AVRational mpeg2_frame_rate_ext
int real_sprite_warping_points
int strict_std_compliance
strictly follow the std (MPEG-4, ...)
int last_lambda_for[5]
last lambda for a specific pict type
int64_t dts_delta
pts difference between the first and second input frame, used for calculating dts of the first frame ...
Picture last_picture
copy of the previous picture structure.
int frame_bits
bits used for the current frame
int16_t(* blocks)[12][64]
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
ScanTable intra_v_scantable
int64_t time
time of current frame
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & MPEG-1 specific
int pb_frame
PB-frame mode (0 = none, 1 = base, 2 = improved)
uint8_t *[2][2] b_field_select_table
int last_bits
temp var used for calculating the above vars
uint8_t * inter_ac_vlc_length
int closed_gop
MPEG1/2 GOP is closed.
uint16_t pp_time
time distance between the last 2 p,s,i frames
int32_t(* block32)[12][64]
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced B-frame encoding.
int h263_aic
Advanced INTRA Coding (AIC)
PutBitContext pb2
used for data partitioned VOPs
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
int sprite_warping_accuracy
int skipdct
skip dct and code zero residual
int16_t(* b_direct_mv_table_base)[2]
int stuffing_bits
bits used for stuffing
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
int umvplus
== H.263+ && unrestricted_mv
int alt_inter_vlc
alternative inter vlc
int h263_flv
use flv H.263 header
int sprite_offset[2][2]
sprite offset[isChroma][isMVY]
uint16_t(* q_inter_matrix16)[2][64]
int block_last_index[12]
last non zero coefficient in block
uint8_t * cbp_table
used to store cbp, ac_pred for partitioned decoding
int chroma_qscale
chroma QP
uint8_t * luma_dc_vlc_length
int b_code
backward MV resolution for B-frames (MPEG-4)
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
uint16_t pb_field_time
like above, just for interlaced
int misc_bits
cbp, mb_type
int dct_precision
number of bits to represent the fractional part of time (encoder only)
unsigned int allocated_bitstream_buffer_size
GetBitContext last_resync_gb
used to search for the next resync marker
float rc_qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
int last_dc[3]
last DC values for MPEG-1
uint8_t * intra_ac_vlc_length
uint8_t * intra_ac_vlc_last_length
int encoding
true if we are encoding (vs decoding)
int inter_quant_bias
bias for the quantizer
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed B-frames
int low_delay
no reordering needed / has no B-frames
int picture_in_gop_number
0-> first pic in gop, ...
int first_field
is 1 for the first field of a field picture 0 otherwise
PutBitContext pb
bit output
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int bitstream_buffer_size
int mpv_flags
flags set by private options
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Picture new_picture
copy of the source picture structure for encoding.
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int16_t(* dpcm_macroblock)[3][256]
int64_t timecode_frame_start
GOP timecode frame start number, in non drop frame format.
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
int mb_skipped
MUST BE SET only during DECODING.
uint8_t * coded_block_base
int mb_num
number of MBs of a picture
int quantizer_noise_shaping
int next_lambda
next lambda used for retrying to encode a frame
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
int dquant
qscale difference to prev qscale
int mb_info
interval for outputting info about mb offsets as side data
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int concealment_motion_vectors
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for B-frame encodin...
uint8_t * inter_ac_vlc_last_length
int quarter_sample
1->qpel, 0->half pel ME/MC
int rl_chroma_table_index
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
int motion_est
ME algorithm.
int time_base
time in seconds of last I,P,S Frame
int h263_slice_structured
int me_pre
prepass for motion estimation
Picture * current_picture_ptr
pointer to the current picture
int first_slice_line
used in MPEG-4 too to handle resync markers
int chroma_elim_threshold
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
uint16_t chroma_inter_matrix[64]
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
int16_t(* b_forw_mv_table_base)[2]
int resync_mb_y
y position of last resync marker
ScanTable intra_scantable
int16_t direct_scale_mv[2][64]
precomputed to avoid divisions in ff_mpeg4_set_direct_mv
int16_t(* b_bidir_back_mv_table_base)[2]
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
int16_t(*[2][2] p_field_mv_table_base)[2]
H264ChromaContext h264chroma
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode B-frame encoding.
int16_t(* b_back_mv_table_base)[2]
Picture current_picture
copy of the current picture structure.
int height
picture size. must be a multiple of 16
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
int unrestricted_mv
mv can point outside of the coded picture
int max_b_frames
max number of B-frames for encoding
Picture * last_picture_ptr
pointer to the previous picture.
int last_mv_dir
last mv_dir, used for B-frame encoding
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
int16_t(*[12] pblocks)[64]
Picture next_picture
copy of the next picture structure.
uint16_t(* dct_offset)[64]
int max_qcoeff
maximum encodable coefficient
enum OutputFormat out_format
output format
int min_qcoeff
minimum encodable coefficient
MpegvideoEncDSPContext mpvencdsp
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
Picture ** reordered_input_picture
pointer to the next pictures in coded order for encoding
AVTimecode tc
timecode context
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
int sprite_delta[2][2]
sprite_delta [isY][isMVY]
int(* q_chroma_intra_matrix)[64]
int resync_mb_x
x position of last resync marker
int slice_height
in macroblocks
uint16_t chroma_intra_matrix[64]
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
struct AVCodecContext * avctx
Core video DSP helper functions.