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)) 477 #define VIDEO_FORMAT_COMPONENT 0 478 #define VIDEO_FORMAT_PAL 1 479 #define VIDEO_FORMAT_NTSC 2 480 #define VIDEO_FORMAT_SECAM 3 481 #define VIDEO_FORMAT_MAC 4 482 #define VIDEO_FORMAT_UNSPECIFIED 5 520 #define SLICE_ERROR -1 522 #define SLICE_NOEND -3
527 int16_t *block,
int n,
int qscale);
529 int16_t *block,
int n,
int qscale);
531 int16_t *block,
int n,
int qscale);
533 int16_t *block,
int n,
int qscale);
535 int16_t *block,
int n,
int qscale);
537 int16_t *block,
int n,
int qscale);
539 int16_t *block,
int n,
int qscale);
591 #define FF_MPV_FLAG_SKIP_RD 0x0001 592 #define FF_MPV_FLAG_STRICT_GOP 0x0002 593 #define FF_MPV_FLAG_QP_RD 0x0004 594 #define FF_MPV_FLAG_CBP_RD 0x0008 595 #define FF_MPV_FLAG_NAQ 0x0010 596 #define FF_MPV_FLAG_MV0 0x0020 598 #define FF_MPV_OPT_CMP_FUNC \ 599 { "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" }, \ 600 { "sse", "Sum of squared errors", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 601 { "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" }, \ 602 { "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" }, \ 603 { "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" }, \ 604 { "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" }, \ 605 { "rd", "Rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_RD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 606 { "zero", "Zero", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_ZERO }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 607 { "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" }, \ 608 { "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" }, \ 609 { "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" }, \ 610 { "dct264", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT264 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 611 { "dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 612 { "chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_CHROMA }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \ 613 { "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" } 615 #ifndef FF_MPV_OFFSET 616 #define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x) 618 #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) 619 #define FF_MPV_COMMON_OPTS \ 620 FF_MPV_OPT_CMP_FUNC, \ 621 { "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" },\ 622 { "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" },\ 623 { "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" },\ 624 { "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" },\ 625 { "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" },\ 626 { "naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\ 627 { "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" },\ 628 { "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\ 629 FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\ 630 { "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\ 631 FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\ 632 { "quantizer_noise_shaping", NULL, FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\ 633 { "error_rate", "Simulate errors in the bitstream to test error concealment.", \ 634 FF_MPV_OFFSET(error_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },\ 635 {"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", \ 636 FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS}, \ 637 {"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}, \ 638 {"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}, \ 639 {"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions " \ 640 "defined in the section 'Expression Evaluation', the following functions are available: " \ 641 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv " \ 642 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.", \ 643 FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING, .flags = FF_MPV_OPT_FLAGS }, \ 644 {"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}, \ 645 {"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}, \ 646 {"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}, \ 647 {"lmin", "minimum Lagrange factor (VBR)", FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 = 2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \ 648 {"lmax", "maximum Lagrange factor (VBR)", FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS }, \ 649 {"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 }, \ 650 {"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 }, \ 651 {"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" }, \ 652 { "ffmpeg", "deprecated, does nothing", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED, "rc_strategy" }, \ 653 { "xvid", "deprecated, does nothing", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED, "rc_strategy" }, \ 654 {"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" }, \ 655 { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ 656 { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ 657 { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \ 658 { "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 }, \ 659 {"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 }, \ 660 {"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 }, \ 661 {"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 }, \ 662 {"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 }, \ 663 {"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 }, \ 664 {"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 }, \ 665 {"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" }, \ 666 {"sc_threshold", "Scene change threshold", FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \ 667 {"noise_reduction", "Noise reduction", FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \ 668 {"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 }, \ 669 {"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 }, \ 670 {"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 }, \ 671 {"mepre", "pre motion estimation", FF_MPV_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \ 672 {"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 }, \ 673 {"a53cc", "Use A53 Closed Captions (if available)", FF_MPV_OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FF_MPV_OPT_FLAGS }, \ 729 const uint16_t *quant_matrix,
int bias,
int qmin,
int qmax,
int intra);
732 const uint8_t *scantable,
int last);
744 const int block_size= (8*bytes_per_pixel) >> s->
avctx->
lowres;
752 s->
dest[0]+= 2*block_size;
int bitstream_buffer_size
int chroma_elim_threshold
int rv10_first_dc_coded[3]
int frame_bits
bits used for the current frame
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
int16_t(* b_bidir_back_mv_table_base)[2]
int64_t timecode_frame_start
GOP timecode frame start number, in non drop frame format.
Holds JPEG frame data and Huffman table data.
ScanTable intra_v_scantable
This structure describes decoded (raw) audio or video data.
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
int sprite_warping_accuracy
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
void ff_init_block_index(MpegEncContext *s)
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
AVFrame * tmp_frames[MAX_B_FRAMES+2]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
uint8_t * coded_block_base
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
uint16_t(* q_chroma_intra_matrix16)[2][64]
uint16_t chroma_intra_matrix[64]
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
uint16_t chroma_inter_matrix[64]
void ff_mpv_frame_end(MpegEncContext *s)
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
uint8_t * bitstream_buffer
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
int obmc
overlapped block motion compensation
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)
int scan_offset
reserve space for SVCD scan offset user data.
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
int16_t(* p_mv_table_base)[2]
int min_qcoeff
minimum encodable coefficient
int real_sprite_warping_points
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
int mpv_flags
flags set by private options
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
uint8_t * intra_ac_vlc_length
int padding_bug_score
used to detect the VERY common padding bug in MPEG-4
int mb_num
number of MBs of a picture
int time_base
time in seconds of last I,P,S Frame
Undefined Behavior In the C some operations are like signed integer overflow
int h263_aic
Advanced INTRA Coding (AIC)
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode B-frame encoding.
int encoding
true if we are encoding (vs decoding)
int16_t(* b_back_mv_table_base)[2]
int skipdct
skip dct and code zero residual
float rc_buffer_aggressivity
const uint8_t ff_mpeg2_non_linear_qscale[32]
int picture_in_gop_number
0-> first pic in gop, ...
int alt_inter_vlc
alternative inter vlc
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
int64_t time
time of current frame
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
const AVOption ff_mpv_generic_options[]
AVRational mpeg2_frame_rate_ext
Picture ** input_picture
next pictures on display order for encoding
PutBitContext pb2
used for data partitioned VOPs
enum OutputFormat out_format
output format
uint16_t(* dct_offset)[64]
void ff_dct_encode_init_x86(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])
uint8_t * pred_dir_table
used to store pred_dir for partitioned decoding
Multithreading support functions.
Motion estimation context.
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
int force_duplicated_matrix
Force duplication of mjpeg matrices, useful for rtp streaming.
int misc_bits
cbp, mb_type
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
int(* q_chroma_intra_matrix)[64]
Picture current_picture
copy of the current picture structure.
GetBitContext last_resync_gb
used to search for the next resync marker
void ff_mpv_common_init_arm(MpegEncContext *s)
void ff_mpv_common_init_ppc(MpegEncContext *s)
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
bitstream reader API header.
uint16_t pp_time
time distance between the last 2 p,s,i frames
int mb_height
number of MBs horizontally & vertically
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
int max_qcoeff
maximum encodable coefficient
int16_t(*[2][2] p_field_mv_table_base)[2]
int scenechange_threshold
int dquant
qscale difference to prev qscale
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & MPEG-1 specific
static void ff_update_block_index(MpegEncContext *s)
int sprite_offset[2][2]
sprite offset[isChroma][isMVY]
int(* q_inter_matrix)[64]
static int get_bits_diff(MpegEncContext *s)
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
int intra_only
if true, only intra pictures are generated
int16_t * dc_val[3]
used for MPEG-4 DC prediction, all 3 arrays must be continuous
int h263_plus
H.263+ headers.
int slice_context_count
number of used thread_contexts
int last_non_b_pict_type
used for MPEG-4 gmc B-frames & ratecontrol
AVCodecID
Identify the syntax and semantics of the bitstream.
int last_dc[3]
last DC values for MPEG-1
int16_t direct_scale_mv[2][64]
precomputed to avoid divisions in ff_mpeg4_set_direct_mv
uint8_t * inter_ac_vlc_last_length
int rl_chroma_table_index
int mb_skipped
MUST BE SET only during DECODING.
int rc_strategy
deprecated
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
int strict_std_compliance
strictly follow the std (MPEG-4, ...)
int partitioned_frame
is current frame partitioned
void ff_mpv_common_end(MpegEncContext *s)
int unrestricted_mv
mv can point outside of the coded picture
int last_lambda_for[5]
last lambda for a specific pict type
uint8_t * intra_chroma_ac_vlc_length
int h263_slice_structured
MpegvideoEncDSPContext mpvencdsp
int(* decode_mb)(struct MpegEncContext *s, int16_t block[12][64])
int quarter_sample
1->qpel, 0->half pel ME/MC
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
int me_pre
prepass for motion estimation
int low_delay
no reordering needed / has no B-frames
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
uint8_t *[2][2] b_field_select_table
static int put_bits_count(PutBitContext *s)
int resync_mb_x
x position of last resync marker
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
void ff_mpv_common_init_mips(MpegEncContext *s)
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
int dct_precision
number of bits to represent the fractional part of time (encoder only)
void ff_mpv_common_init_neon(MpegEncContext *s)
uint8_t * intra_ac_vlc_last_length
int sprite_delta[2][2]
sprite_delta [isY][isMVY]
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
uint16_t(* q_inter_matrix16)[2][64]
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
int fixed_qscale
fixed qscale if non zero
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed B-frames
int umvplus
== H.263+ && unrestricted_mv
Picture new_picture
copy of the source picture structure for encoding.
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int intra_quant_bias
bias for the quantizer
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for B-frame encodin...
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
Picture * current_picture_ptr
pointer to the current picture
unsigned int allocated_bitstream_buffer_size
int16_t(* ac_val_base)[16]
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
int16_t(*[2][2][2] b_field_mv_table_base)[2]
int(* ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2]
[mb_intra][isChroma][level][run][last]
int16_t(* b_forw_mv_table_base)[2]
int16_t(*[12] pblocks)[64]
int block_last_index[12]
last non zero coefficient in block
int pb_frame
PB-frame mode (0 = none, 1 = base, 2 = improved)
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int ac_esc_length
num of bits needed to encode the longest esc
const uint8_t * fcode_tab
smallest fcode needed for each MV
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
int block_index[6]
index to current MB in block based arrays with edges
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
void ff_mpeg_flush(AVCodecContext *avctx)
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
void ff_mpv_common_init_x86(MpegEncContext *s)
struct MJpegContext * mjpeg_ctx
int first_field
is 1 for the first field of a field picture 0 otherwise
void ff_mpv_idct_init(MpegEncContext *s)
int first_slice_line
used in MPEG-4 too to handle resync markers
int16_t(* b_bidir_forw_mv_table_base)[2]
uint16_t inter_matrix[64]
uint8_t * luma_dc_vlc_length
int concealment_motion_vectors
struct MpegEncContext * thread_context[MAX_THREADS]
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Libavcodec external API header.
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
int h263_flv
use flv H.263 header
char * tc_opt_str
timecode option string
ptrdiff_t linesize
line size, in bytes, may be different from width
uint8_t * intra_chroma_ac_vlc_last_length
main external API structure.
ScanTable intra_scantable
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
int height
picture size. must be a multiple of 16
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
int ff_dct_encode_init(MpegEncContext *s)
int64_t dts_delta
pts difference between the first and second input frame, used for calculating dts of the first frame ...
int64_t user_specified_pts
last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int ff_mpv_encode_init(AVCodecContext *avctx)
Picture * picture
main picture buffer
int data_partitioning
data partitioning flag from header
uint8_t * inter_ac_vlc_length
Describe the class of an AVClass context structure.
int stuffing_bits
bits used for stuffing
ScanTable intra_h_scantable
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced B-frame encoding.
uint8_t * cbp_table
used to store cbp, ac_pred for partitioned decoding
int closed_gop
MPEG1/2 GOP is closed.
Rational number (pair of numerator and denominator).
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
void ff_mpv_common_init_axp(MpegEncContext *s)
int input_picture_number
used to set pic->display_picture_number, should not be used for/by anything else
int slice_height
in macroblocks
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
int mb_info
interval for outputting info about mb offsets as side data
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
int f_code
forward MV resolution
void(* denoise_dct)(struct MpegEncContext *s, int16_t *block)
int max_b_frames
max number of B-frames for encoding
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
int last_mv_dir
last mv_dir, used for B-frame encoding
int motion_est
ME algorithm.
int h263_pred
use MPEG-4/H.263 ac/dc predictions
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
uint8_t *[2] p_field_select_table
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode B-frame encoding.
uint16_t pb_field_time
like above, just for interlaced
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
int me_penalty_compensation
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode B-frame encoding.
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
struct AVCodecContext * avctx
PutBitContext pb
bit output
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int quantizer_noise_shaping
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
static const int32_t qmat16[MAT_SIZE]
common internal api header.
int32_t(* block32)[12][64]
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
int adaptive_quant
use adaptive quantization
Picture last_picture
copy of the previous picture structure.
Picture * last_picture_ptr
pointer to the previous picture.
float rc_qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
int64_t reordered_pts
reordered pts to be used as dts for the next output frame when there's a delay
int ff_mpv_encode_end(AVCodecContext *avctx)
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Core video DSP helper functions.
H264ChromaContext h264chroma
int16_t(* blocks)[12][64]
int last_bits
temp var used for calculating the above vars
void ff_mpv_encode_init_x86(MpegEncContext *s)
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int drop_frame_timecode
timecode is in drop frame format.
int resync_mb_y
y position of last resync marker
int16_t(* block)[64]
points to one of the following blocks
ParseContext parse_context
int64_t bit_rate
wanted bit rate
PutBitContext tex_pb
used for data partitioned VOPs
Picture next_picture
copy of the next picture structure.
Picture ** reordered_input_picture
pointer to the next pictures in coded order for encoding
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
int chroma_qscale
chroma QP
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
void ff_mpv_report_decode_progress(MpegEncContext *s)
int16_t(* dpcm_macroblock)[3][256]
int rv10_version
RV10 version: 0 or 3.
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
static int mpeg_get_qscale(MpegEncContext *s)
int h263_long_vectors
use horrible H.263v1 long vector mode
int inter_quant_bias
bias for the quantizer
int16_t(* b_direct_mv_table_base)[2]
int b_code
backward MV resolution for B-frames (MPEG-4)
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVTimecode tc
timecode context
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
This structure stores compressed data.
unsigned int lambda
Lagrange multiplier used in rate distortion.
uint16_t pb_time
time distance between the last b and p,s,i frame
int next_lambda
next lambda used for retrying to encode a frame