avcodec.AVCodecContext (JavaCPP Presets for FFmpeg 2.3-0.9 API)

java.lang.Object
- org.bytedeco.javacpp.Pointer
- - org.bytedeco.javacpp.avcodec.AVCodecContext

Enclosing class:

avcodec
```
public static class avcodec.AVCodecContext
extends Pointer
```
main external API structure. New fields can be added to the end with minor version bumps. Removal, reordering and changes to existing fields require a major version bump. Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user applications. sizeof(AVCodecContext) must not be used outside libav*.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`avcodec.AVCodecContext.Draw_horiz_band_AVCodecContext_AVFrame_IntPointer_int_int_int` If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
`static class`	`avcodec.AVCodecContext.Execute_AVCodecContext_Func_AVCodecContext_Pointer_Pointer_IntPointer_int_int`
`static class`	`avcodec.AVCodecContext.Execute2_AVCodecContext_Func_AVCodecContext_Pointer_int_int_Pointer_IntPointer_int`
`static class`	`avcodec.AVCodecContext.Func_AVCodecContext_Pointer` The codec may call this to execute several independent things.
`static class`	`avcodec.AVCodecContext.Func_AVCodecContext_Pointer_int_int` The codec may call this to execute several independent things.
`static class`	`avcodec.AVCodecContext.Get_buffer_AVCodecContext_AVFrame` Deprecated. use get_buffer2()
`static class`	`avcodec.AVCodecContext.Get_buffer2_AVCodecContext_AVFrame_int` This callback is called at the beginning of each frame to get data buffer(s) for it.
`static class`	`avcodec.AVCodecContext.Get_format_AVCodecContext_IntPointer` callback to negotiate the pixelFormat
`static class`	`avcodec.AVCodecContext.Reget_buffer_AVCodecContext_AVFrame` Called at the beginning of a frame to get cr buffer for it.
`static class`	`avcodec.AVCodecContext.Release_buffer_AVCodecContext_AVFrame` Deprecated. custom freeing callbacks should be set from get_buffer2()
`static class`	`avcodec.AVCodecContext.Rtp_callback_AVCodecContext_Pointer_int_int`

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer
Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AV_EF_AGGRESSIVE` consider things that a sane encoder should not do as an error
`static int`	`AV_EF_BITSTREAM` detect bitstream specification deviations
`static int`	`AV_EF_BUFFER` detect improper bitstream length
`static int`	`AV_EF_CAREFUL` consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
`static int`	`AV_EF_COMPLIANT` consider all spec non compliances as errors
`static int`	`AV_EF_CRCCHECK` Verify checksums embedded in the bitstream (could be of either encoded or decoded data, depending on the codec) and print an error message on mismatch.
`static int`	`AV_EF_EXPLODE` abort decoding on minor error detection
`static int`	`AV_EF_IGNORE_ERR` ignore errors and continue
`static int`	`FF_ASPECT_EXTENDED`
`static int`	`FF_BUG_AC_VLC` Will be removed, libavcodec can now handle these non-compliant files by default.
`static int`	`FF_BUG_AMV`
`static int`	`FF_BUG_AUTODETECT` autodetection
`static int`	`FF_BUG_DC_CLIP`
`static int`	`FF_BUG_DIRECT_BLOCKSIZE`
`static int`	`FF_BUG_EDGE`
`static int`	`FF_BUG_HPEL_CHROMA`
`static int`	`FF_BUG_MS` Work around various bugs in Microsoft's broken decoders.
`static int`	`FF_BUG_NO_PADDING`
`static int`	`FF_BUG_OLD_MSMPEG4`
`static int`	`FF_BUG_QPEL_CHROMA`
`static int`	`FF_BUG_QPEL_CHROMA2`
`static int`	`FF_BUG_STD_QPEL`
`static int`	`FF_BUG_TRUNCATED`
`static int`	`FF_BUG_UMP4`
`static int`	`FF_BUG_XVID_ILACE`
`static int`	`FF_CMP_BIT`
`static int`	`FF_CMP_CHROMA`
`static int`	`FF_CMP_DCT`
`static int`	`FF_CMP_DCT264`
`static int`	`FF_CMP_DCTMAX`
`static int`	`FF_CMP_NSSE`
`static int`	`FF_CMP_PSNR`
`static int`	`FF_CMP_RD`
`static int`	`FF_CMP_SAD`
`static int`	`FF_CMP_SATD`
`static int`	`FF_CMP_SSE`
`static int`	`FF_CMP_VSAD`
`static int`	`FF_CMP_VSSE`
`static int`	`FF_CMP_W53`
`static int`	`FF_CMP_W97`
`static int`	`FF_CMP_ZERO`
`static int`	`FF_CODER_TYPE_AC`
`static int`	`FF_CODER_TYPE_DEFLATE`
`static int`	`FF_CODER_TYPE_RAW`
`static int`	`FF_CODER_TYPE_RLE`
`static int`	`FF_CODER_TYPE_VLC`
`static int`	`FF_COMPLIANCE_EXPERIMENTAL` Allow nonstandardized experimental things.
`static int`	`FF_COMPLIANCE_NORMAL`
`static int`	`FF_COMPLIANCE_STRICT` Strictly conform to all the things in the spec no matter what consequences.
`static int`	`FF_COMPLIANCE_UNOFFICIAL` Allow unofficial extensions
`static int`	`FF_COMPLIANCE_VERY_STRICT` Strictly conform to an older more strict version of the spec or reference software.
`static int`	`FF_COMPRESSION_DEFAULT`
`static int`	`FF_DCT_ALTIVEC`
`static int`	`FF_DCT_AUTO`
`static int`	`FF_DCT_FAAN`
`static int`	`FF_DCT_FASTINT`
`static int`	`FF_DCT_INT`
`static int`	`FF_DCT_MMX`
`static int`	`FF_DEBUG_BITSTREAM`
`static int`	`FF_DEBUG_BUFFERS`
`static int`	`FF_DEBUG_BUGS`
`static int`	`FF_DEBUG_DCT_COEFF`
`static int`	`FF_DEBUG_ER`
`static int`	`FF_DEBUG_MB_TYPE`
`static int`	`FF_DEBUG_MMCO`
`static int`	`FF_DEBUG_MV` Deprecated. this option does nothing
`static int`	`FF_DEBUG_NOMC`
`static int`	`FF_DEBUG_PICT_INFO`
`static int`	`FF_DEBUG_PTS`
`static int`	`FF_DEBUG_QP`
`static int`	`FF_DEBUG_RC`
`static int`	`FF_DEBUG_SKIP`
`static int`	`FF_DEBUG_STARTCODE`
`static int`	`FF_DEBUG_THREADS`
`static int`	`FF_DEBUG_VIS_MB_TYPE` only access through AVOptions from outside libavcodec
`static int`	`FF_DEBUG_VIS_MV_B_BACK`
`static int`	`FF_DEBUG_VIS_MV_B_FOR`
`static int`	`FF_DEBUG_VIS_MV_P_FOR`
`static int`	`FF_DEBUG_VIS_QP` only access through AVOptions from outside libavcodec
`static int`	`FF_DEFAULT_QUANT_BIAS`
`static int`	`FF_DTG_AFD_14_9`
`static int`	`FF_DTG_AFD_16_9`
`static int`	`FF_DTG_AFD_16_9_SP_14_9`
`static int`	`FF_DTG_AFD_4_3`
`static int`	`FF_DTG_AFD_4_3_SP_14_9`
`static int`	`FF_DTG_AFD_SAME`
`static int`	`FF_DTG_AFD_SP_4_3`
`static int`	`FF_EC_DEBLOCK`
`static int`	`FF_EC_FAVOR_INTER`
`static int`	`FF_EC_GUESS_MVS`
`static int`	`FF_IDCT_ALTIVEC`
`static int`	`FF_IDCT_ARM`
`static int`	`FF_IDCT_AUTO`
`static int`	`FF_IDCT_FAAN`
`static int`	`FF_IDCT_INT`
`static int`	`FF_IDCT_IPP`
`static int`	`FF_IDCT_SH4`
`static int`	`FF_IDCT_SIMPLE`
`static int`	`FF_IDCT_SIMPLEALPHA`
`static int`	`FF_IDCT_SIMPLEARM`
`static int`	`FF_IDCT_SIMPLEARMV5TE`
`static int`	`FF_IDCT_SIMPLEARMV6`
`static int`	`FF_IDCT_SIMPLEAUTO`
`static int`	`FF_IDCT_SIMPLEMMX`
`static int`	`FF_IDCT_SIMPLENEON`
`static int`	`FF_IDCT_SIMPLEVIS`
`static int`	`FF_IDCT_XVIDMMX`
`static int`	`FF_LEVEL_UNKNOWN`
`static int`	`FF_MB_DECISION_BITS` chooses the one which needs the fewest bits
`static int`	`FF_MB_DECISION_RD` rate distortion
`static int`	`FF_MB_DECISION_SIMPLE` uses mb_cmp
`static int`	`FF_PRED_LEFT`
`static int`	`FF_PRED_MEDIAN`
`static int`	`FF_PRED_PLANE`
`static int`	`FF_PROFILE_AAC_ELD`
`static int`	`FF_PROFILE_AAC_HE`
`static int`	`FF_PROFILE_AAC_HE_V2`
`static int`	`FF_PROFILE_AAC_LD`
`static int`	`FF_PROFILE_AAC_LOW`
`static int`	`FF_PROFILE_AAC_LTP`
`static int`	`FF_PROFILE_AAC_MAIN`
`static int`	`FF_PROFILE_AAC_SSR`
`static int`	`FF_PROFILE_DTS`
`static int`	`FF_PROFILE_DTS_96_24`
`static int`	`FF_PROFILE_DTS_ES`
`static int`	`FF_PROFILE_DTS_HD_HRA`
`static int`	`FF_PROFILE_DTS_HD_MA`
`static int`	`FF_PROFILE_H264_BASELINE`
`static int`	`FF_PROFILE_H264_CAVLC_444`
`static int`	`FF_PROFILE_H264_CONSTRAINED`
`static int`	`FF_PROFILE_H264_CONSTRAINED_BASELINE`
`static int`	`FF_PROFILE_H264_EXTENDED`
`static int`	`FF_PROFILE_H264_HIGH`
`static int`	`FF_PROFILE_H264_HIGH_10`
`static int`	`FF_PROFILE_H264_HIGH_10_INTRA`
`static int`	`FF_PROFILE_H264_HIGH_422`
`static int`	`FF_PROFILE_H264_HIGH_422_INTRA`
`static int`	`FF_PROFILE_H264_HIGH_444`
`static int`	`FF_PROFILE_H264_HIGH_444_INTRA`
`static int`	`FF_PROFILE_H264_HIGH_444_PREDICTIVE`
`static int`	`FF_PROFILE_H264_INTRA`
`static int`	`FF_PROFILE_H264_MAIN`
`static int`	`FF_PROFILE_HEVC_MAIN`
`static int`	`FF_PROFILE_HEVC_MAIN_10`
`static int`	`FF_PROFILE_HEVC_MAIN_STILL_PICTURE`
`static int`	`FF_PROFILE_HEVC_REXT`
`static int`	`FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION`
`static int`	`FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0`
`static int`	`FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1`
`static int`	`FF_PROFILE_JPEG2000_DCINEMA_2K`
`static int`	`FF_PROFILE_JPEG2000_DCINEMA_4K`
`static int`	`FF_PROFILE_MPEG2_422`
`static int`	`FF_PROFILE_MPEG2_AAC_HE`
`static int`	`FF_PROFILE_MPEG2_AAC_LOW`
`static int`	`FF_PROFILE_MPEG2_HIGH`
`static int`	`FF_PROFILE_MPEG2_MAIN`
`static int`	`FF_PROFILE_MPEG2_SIMPLE`
`static int`	`FF_PROFILE_MPEG2_SNR_SCALABLE`
`static int`	`FF_PROFILE_MPEG2_SS`
`static int`	`FF_PROFILE_MPEG4_ADVANCED_CODING`
`static int`	`FF_PROFILE_MPEG4_ADVANCED_CORE`
`static int`	`FF_PROFILE_MPEG4_ADVANCED_REAL_TIME`
`static int`	`FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE`
`static int`	`FF_PROFILE_MPEG4_ADVANCED_SIMPLE`
`static int`	`FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE`
`static int`	`FF_PROFILE_MPEG4_CORE`
`static int`	`FF_PROFILE_MPEG4_CORE_SCALABLE`
`static int`	`FF_PROFILE_MPEG4_HYBRID`
`static int`	`FF_PROFILE_MPEG4_MAIN`
`static int`	`FF_PROFILE_MPEG4_N_BIT`
`static int`	`FF_PROFILE_MPEG4_SCALABLE_TEXTURE`
`static int`	`FF_PROFILE_MPEG4_SIMPLE`
`static int`	`FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION`
`static int`	`FF_PROFILE_MPEG4_SIMPLE_SCALABLE`
`static int`	`FF_PROFILE_MPEG4_SIMPLE_STUDIO`
`static int`	`FF_PROFILE_RESERVED`
`static int`	`FF_PROFILE_UNKNOWN`
`static int`	`FF_PROFILE_VC1_ADVANCED`
`static int`	`FF_PROFILE_VC1_COMPLEX`
`static int`	`FF_PROFILE_VC1_MAIN`
`static int`	`FF_PROFILE_VC1_SIMPLE`
`static int`	`FF_RC_STRATEGY_XVID`
`static int`	`FF_SUB_CHARENC_MODE_AUTOMATIC` libavcodec will select the mode itself
`static int`	`FF_SUB_CHARENC_MODE_DO_NOTHING` do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
`static int`	`FF_SUB_CHARENC_MODE_PRE_DECODER` the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
`static int`	`FF_THREAD_FRAME` Decode more than one frame at once
`static int`	`FF_THREAD_SLICE` Decode more than one part of a single frame at once
`static int`	`SLICE_FLAG_ALLOW_FIELD` allow draw_horiz_band() with field slices (MPEG2 field pics)
`static int`	`SLICE_FLAG_ALLOW_PLANE` allow draw_horiz_band() with 1 component at a time (SVQ1)
`static int`	`SLICE_FLAG_CODED_ORDER` draw_horiz_band() is called in coded order instead of display

Fields inherited from class org.bytedeco.javacpp.Pointer
address, capacity, limit, position

Constructor Summary

Constructors
Constructor and Description

avcodec.AVCodecContext()

avcodec.AVCodecContext(int size)

avcodec.AVCodecContext(Pointer p)

Constructors
Constructor and Description
`avcodec.AVCodecContext()`
`avcodec.AVCodecContext(int size)`
`avcodec.AVCodecContext(Pointer p)`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`active_thread_type()` Which multithreading methods are in use by the codec.
`avcodec.AVCodecContext`	`active_thread_type(int active_thread_type)`
`int`	`audio_service_type()` Type of service that the audio stream conveys.
`avcodec.AVCodecContext`	`audio_service_type(int audio_service_type)`
`avutil.AVClass`	`av_class()` information on struct for av_log - set by avcodec_alloc_context3
`int`	`b_frame_strategy()`
`avcodec.AVCodecContext`	`b_frame_strategy(int b_frame_strategy)`
`float`	`b_quant_factor()` qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).
`avcodec.AVCodecContext`	`b_quant_factor(float b_quant_factor)`
`float`	`b_quant_offset()` qscale offset between IP and B-frames - encoding: Set by user.
`avcodec.AVCodecContext`	`b_quant_offset(float b_quant_offset)`
`int`	`b_sensitivity()` Adjust sensitivity of b_frame_strategy 1.
`avcodec.AVCodecContext`	`b_sensitivity(int b_sensitivity)`
`int`	`bidir_refine()` - encoding: Set by user.
`avcodec.AVCodecContext`	`bidir_refine(int bidir_refine)`
`int`	`bit_rate_tolerance()` number of bits the bitstream is allowed to diverge from the reference.
`avcodec.AVCodecContext`	`bit_rate_tolerance(int bit_rate_tolerance)`
`int`	`bit_rate()` the average bitrate - encoding: Set by user; unused for constant quantizer encoding.
`avcodec.AVCodecContext`	`bit_rate(int bit_rate)`
`int`	`bits_per_coded_sample()` bits per sample/pixel from the demuxer (needed for huffyuv).
`avcodec.AVCodecContext`	`bits_per_coded_sample(int bits_per_coded_sample)`
`int`	`bits_per_raw_sample()` Bits per sample/pixel of internal libavcodec pixel/sample format.
`avcodec.AVCodecContext`	`bits_per_raw_sample(int bits_per_raw_sample)`
`int`	`block_align()` number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
`avcodec.AVCodecContext`	`block_align(int block_align)`
`float`	`border_masking()` Border processing masking, raises the quantizer for mbs on the borders of the picture.
`avcodec.AVCodecContext`	`border_masking(float border_masking)`
`int`	`brd_scale()` - encoding: Set by user.
`avcodec.AVCodecContext`	`brd_scale(int brd_scale)`
`long`	`channel_layout()` Audio channel layout.
`avcodec.AVCodecContext`	`channel_layout(long channel_layout)`
`int`	`channels()` number of audio channels
`avcodec.AVCodecContext`	`channels(int channels)`
`ShortPointer`	`chroma_intra_matrix()` custom intra quantization matrix Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix() - encoding: Set by user, can be NULL.
`avcodec.AVCodecContext`	`chroma_intra_matrix(ShortPointer chroma_intra_matrix)`
`int`	`chroma_sample_location()` This defines the location of chroma samples.
`avcodec.AVCodecContext`	`chroma_sample_location(int chroma_sample_location)`
`int`	`chromaoffset()` chroma qp offset from luma - encoding: Set by user.
`avcodec.AVCodecContext`	`chromaoffset(int chromaoffset)`
`avcodec.AVCodecDescriptor`	`codec_descriptor()` AVCodecDescriptor Code outside libavcodec should access this field using: av_codec_{get,set}_codec_descriptor(avctx) - encoding: unused.
`int`	`codec_id()`
`avcodec.AVCodecContext`	`codec_id(int codec_id)`
`BytePointer`	`codec_name()` Deprecated.
`byte`	`codec_name(int i)` Deprecated. this field is not used for anything in libavcodec
`avcodec.AVCodecContext`	`codec_name(int i, byte codec_name)`
`int`	`codec_tag()` fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
`avcodec.AVCodecContext`	`codec_tag(int codec_tag)`
`int`	`codec_type()`
`avcodec.AVCodecContext`	`codec_type(int codec_type)`
`avcodec.AVCodec`	`codec()`
`avutil.AVFrame`	`coded_frame()` the picture in the bitstream - encoding: Set by libavcodec.
`avcodec.AVCodecContext`	`coded_frame(avutil.AVFrame coded_frame)`
`int`	`coded_height()`
`avcodec.AVCodecContext`	`coded_height(int coded_height)`
`int`	`coded_width()` Bitstream width / height, may be different from width/height e.g.
`avcodec.AVCodecContext`	`coded_width(int coded_width)`
`int`	`coder_type()` coder type - encoding: Set by user.
`avcodec.AVCodecContext`	`coder_type(int coder_type)`
`int`	`color_primaries()` Chromaticity coordinates of the source primaries.
`avcodec.AVCodecContext`	`color_primaries(int color_primaries)`
`int`	`color_range()` MPEG vs JPEG YUV range.
`avcodec.AVCodecContext`	`color_range(int color_range)`
`int`	`color_trc()` Color Transfer Characteristic.
`avcodec.AVCodecContext`	`color_trc(int color_trc)`
`int`	`colorspace()` YUV colorspace type.
`avcodec.AVCodecContext`	`colorspace(int colorspace)`
`int`	`compression_level()` - encoding: Set by user.
`avcodec.AVCodecContext`	`compression_level(int compression_level)`
`int`	`context_model()` context model - encoding: Set by user.
`avcodec.AVCodecContext`	`context_model(int context_model)`
`int`	`cutoff()` Audio cutoff bandwidth (0 means "automatic") - encoding: Set by user.
`avcodec.AVCodecContext`	`cutoff(int cutoff)`
`float`	`dark_masking()` darkness masking (0-> disabled) - encoding: Set by user.
`avcodec.AVCodecContext`	`dark_masking(float dark_masking)`
`int`	`dct_algo()` DCT algorithm, see FF_DCT_* below - encoding: Set by user.
`avcodec.AVCodecContext`	`dct_algo(int dct_algo)`
`int`	`debug_mv()` debug Code outside libavcodec should access this field using AVOptions - encoding: Set by user.
`avcodec.AVCodecContext`	`debug_mv(int debug_mv)`
`int`	`debug()` debug - encoding: Set by user.
`avcodec.AVCodecContext`	`debug(int debug)`
`int`	`delay()` Codec delay.
`avcodec.AVCodecContext`	`delay(int delay)`
`int`	`dia_size()` ME diamond size & shape - encoding: Set by user.
`avcodec.AVCodecContext`	`dia_size(int dia_size)`
`avcodec.AVCodecContext.Draw_horiz_band_AVCodecContext_AVFrame_IntPointer_int_int_int`	`draw_horiz_band()`
`avcodec.AVCodecContext`	`draw_horiz_band(avcodec.AVCodecContext.Draw_horiz_band_AVCodecContext_AVFrame_IntPointer_int_int_int draw_horiz_band)`
`int`	`dtg_active_format()` DTG active format information (additional aspect ratio information only used in DVB MPEG-2 transport streams) 0 if not set.
`avcodec.AVCodecContext`	`dtg_active_format(int dtg_active_format)`
`int`	`err_recognition()` Error recognition; may misdetect some more or less valid parts as errors.
`avcodec.AVCodecContext`	`err_recognition(int err_recognition)`
`int`	`error_concealment()` error concealment flags - encoding: unused - decoding: Set by user.
`avcodec.AVCodecContext`	`error_concealment(int error_concealment)`
`int`	`error_rate()` Deprecated. use the 'error_rate' private AVOption of the mpegvideo encoders
`avcodec.AVCodecContext`	`error_rate(int error_rate)`
`LongPointer`	`error()`
`long`	`error(int i)` error - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
`avcodec.AVCodecContext`	`error(int i, long error)`
`avcodec.AVCodecContext.Execute_AVCodecContext_Func_AVCodecContext_Pointer_Pointer_IntPointer_int_int`	`execute()`
`avcodec.AVCodecContext`	`execute(avcodec.AVCodecContext.Execute_AVCodecContext_Func_AVCodecContext_Pointer_Pointer_IntPointer_int_int execute)`
`avcodec.AVCodecContext.Execute2_AVCodecContext_Func_AVCodecContext_Pointer_int_int_Pointer_IntPointer_int`	`execute2()`
`avcodec.AVCodecContext`	`execute2(avcodec.AVCodecContext.Execute2_AVCodecContext_Func_AVCodecContext_Pointer_int_int_Pointer_IntPointer_int execute2)`
`int`	`extradata_size()`
`avcodec.AVCodecContext`	`extradata_size(int extradata_size)`
`BytePointer`	`extradata()` some codecs need / can use extradata like Huffman tables.
`avcodec.AVCodecContext`	`extradata(BytePointer extradata)`
`int`	`field_order()` Field order - encoding: set by libavcodec - decoding: Set by user.
`avcodec.AVCodecContext`	`field_order(int field_order)`
`int`	`flags()` CODEC_FLAG_*.
`avcodec.AVCodecContext`	`flags(int flags)`
`int`	`flags2()` CODEC_FLAG2_* - encoding: Set by user.
`avcodec.AVCodecContext`	`flags2(int flags2)`
`int`	`frame_bits()` number of bits used for the previously encoded frame - encoding: Set by libavcodec.
`avcodec.AVCodecContext`	`frame_bits(int frame_bits)`
`int`	`frame_number()` Frame counter, set by libavcodec.
`avcodec.AVCodecContext`	`frame_number(int frame_number)`
`int`	`frame_size()` Number of samples per channel in an audio frame.
`avcodec.AVCodecContext`	`frame_size(int frame_size)`
`int`	`frame_skip_cmp()` frame skip comparison function - encoding: Set by user.
`avcodec.AVCodecContext`	`frame_skip_cmp(int frame_skip_cmp)`
`int`	`frame_skip_exp()` frame skip exponent - encoding: Set by user.
`avcodec.AVCodecContext`	`frame_skip_exp(int frame_skip_exp)`
`int`	`frame_skip_factor()` frame skip factor - encoding: Set by user.
`avcodec.AVCodecContext`	`frame_skip_factor(int frame_skip_factor)`
`int`	`frame_skip_threshold()` frame skip threshold - encoding: Set by user.
`avcodec.AVCodecContext`	`frame_skip_threshold(int frame_skip_threshold)`
`avcodec.AVCodecContext.Get_buffer_AVCodecContext_AVFrame`	`get_buffer()`
`avcodec.AVCodecContext`	`get_buffer(avcodec.AVCodecContext.Get_buffer_AVCodecContext_AVFrame get_buffer)`
`avcodec.AVCodecContext.Get_buffer2_AVCodecContext_AVFrame_int`	`get_buffer2()`
`avcodec.AVCodecContext`	`get_buffer2(avcodec.AVCodecContext.Get_buffer2_AVCodecContext_AVFrame_int get_buffer2)`
`avcodec.AVCodecContext.Get_format_AVCodecContext_IntPointer`	`get_format()`
`avcodec.AVCodecContext`	`get_format(avcodec.AVCodecContext.Get_format_AVCodecContext_IntPointer get_format)`
`int`	`global_quality()` Global quality for codecs which cannot change it per frame.
`avcodec.AVCodecContext`	`global_quality(int global_quality)`
`int`	`gop_size()` the number of pictures in a group of pictures, or 0 for intra_only - encoding: Set by user.
`avcodec.AVCodecContext`	`gop_size(int gop_size)`
`int`	`has_b_frames()` Size of the frame reordering buffer in the decoder.
`avcodec.AVCodecContext`	`has_b_frames(int has_b_frames)`
`int`	`header_bits()`
`avcodec.AVCodecContext`	`header_bits(int header_bits)`
`int`	`height()`
`avcodec.AVCodecContext`	`height(int height)`
`Pointer`	`hwaccel_context()` Hardware accelerator context.
`avcodec.AVCodecContext`	`hwaccel_context(Pointer hwaccel_context)`
`avcodec.AVHWAccel`	`hwaccel()` Hardware accelerator in use - encoding: unused.
`avcodec.AVCodecContext`	`hwaccel(avcodec.AVHWAccel hwaccel)`
`int`	`i_count()`
`avcodec.AVCodecContext`	`i_count(int i_count)`
`float`	`i_quant_factor()` qscale factor between P and I-frames If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset).
`avcodec.AVCodecContext`	`i_quant_factor(float i_quant_factor)`
`float`	`i_quant_offset()` qscale offset between P and I-frames - encoding: Set by user.
`avcodec.AVCodecContext`	`i_quant_offset(float i_quant_offset)`
`int`	`i_tex_bits()`
`avcodec.AVCodecContext`	`i_tex_bits(int i_tex_bits)`
`int`	`idct_algo()` IDCT algorithm, see FF_IDCT_* below.
`avcodec.AVCodecContext`	`idct_algo(int idct_algo)`
`int`	`ildct_cmp()` interlaced DCT comparison function - encoding: Set by user.
`avcodec.AVCodecContext`	`ildct_cmp(int ildct_cmp)`
`ShortPointer`	`inter_matrix()` custom inter quantization matrix - encoding: Set by user, can be NULL.
`avcodec.AVCodecContext`	`inter_matrix(ShortPointer inter_matrix)`
`int`	`inter_quant_bias()` inter quantizer bias - encoding: Set by user.
`avcodec.AVCodecContext`	`inter_quant_bias(int inter_quant_bias)`
`avcodec.AVCodecInternal`	`internal()` Private context used for internal data.
`avcodec.AVCodecContext`	`internal(avcodec.AVCodecInternal internal)`
`int`	`intra_dc_precision()` precision of the intra DC coefficient - 8 - encoding: Set by user.
`avcodec.AVCodecContext`	`intra_dc_precision(int intra_dc_precision)`
`ShortPointer`	`intra_matrix()` custom intra quantization matrix - encoding: Set by user, can be NULL.
`avcodec.AVCodecContext`	`intra_matrix(ShortPointer intra_matrix)`
`int`	`intra_quant_bias()` intra quantizer bias - encoding: Set by user.
`avcodec.AVCodecContext`	`intra_quant_bias(int intra_quant_bias)`
`int`	`keyint_min()` minimum GOP size - encoding: Set by user.
`avcodec.AVCodecContext`	`keyint_min(int keyint_min)`
`int`	`last_predictor_count()` amount of previous MV predictors (2a+1 x 2a+1 square) - encoding: Set by user.
`avcodec.AVCodecContext`	`last_predictor_count(int last_predictor_count)`
`int`	`level()` level - encoding: Set by user.
`avcodec.AVCodecContext`	`level(int level)`
`int`	`lmax()` maximum Lagrange multiplier - encoding: Set by user.
`avcodec.AVCodecContext`	`lmax(int lmax)`
`int`	`lmin()` minimum Lagrange multiplier - encoding: Set by user.
`avcodec.AVCodecContext`	`lmin(int lmin)`
`int`	`log_level_offset()`
`avcodec.AVCodecContext`	`log_level_offset(int log_level_offset)`
`int`	`lowres()` low resolution decoding, 1-> 1/2 size, 2->1/4 size - encoding: unused - decoding: Set by user.
`avcodec.AVCodecContext`	`lowres(int lowres)`
`float`	`lumi_masking()` luminance masking (0-> disabled) - encoding: Set by user.
`avcodec.AVCodecContext`	`lumi_masking(float lumi_masking)`
`int`	`max_b_frames()` maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 relative to the input.
`avcodec.AVCodecContext`	`max_b_frames(int max_b_frames)`
`int`	`max_prediction_order()` - encoding: Set by user.
`avcodec.AVCodecContext`	`max_prediction_order(int max_prediction_order)`
`int`	`max_qdiff()` maximum quantizer difference between frames - encoding: Set by user.
`avcodec.AVCodecContext`	`max_qdiff(int max_qdiff)`
`int`	`mb_cmp()` macroblock comparison function (not supported yet) - encoding: Set by user.
`avcodec.AVCodecContext`	`mb_cmp(int mb_cmp)`
`int`	`mb_decision()` macroblock decision mode - encoding: Set by user.
`avcodec.AVCodecContext`	`mb_decision(int mb_decision)`
`int`	`mb_lmax()` maximum MB lagrange multipler - encoding: Set by user.
`avcodec.AVCodecContext`	`mb_lmax(int mb_lmax)`
`int`	`mb_lmin()` minimum MB lagrange multipler - encoding: Set by user.
`avcodec.AVCodecContext`	`mb_lmin(int mb_lmin)`
`int`	`mb_threshold()` Macroblock threshold below which the user specified macroblock types will be used.
`avcodec.AVCodecContext`	`mb_threshold(int mb_threshold)`
`int`	`me_cmp()` motion estimation comparison function - encoding: Set by user.
`avcodec.AVCodecContext`	`me_cmp(int me_cmp)`
`int`	`me_method()` Motion estimation algorithm used for video coding.
`avcodec.AVCodecContext`	`me_method(int me_method)`
`int`	`me_penalty_compensation()` - encoding: Set by user.
`avcodec.AVCodecContext`	`me_penalty_compensation(int me_penalty_compensation)`
`int`	`me_pre_cmp()` motion estimation prepass comparison function - encoding: Set by user.
`avcodec.AVCodecContext`	`me_pre_cmp(int me_pre_cmp)`
`int`	`me_range()` maximum motion estimation search range in subpel units If 0 then no limit.
`avcodec.AVCodecContext`	`me_range(int me_range)`
`int`	`me_sub_cmp()` subpixel motion estimation comparison function - encoding: Set by user.
`avcodec.AVCodecContext`	`me_sub_cmp(int me_sub_cmp)`
`int`	`me_subpel_quality()` subpel ME quality - encoding: Set by user.
`avcodec.AVCodecContext`	`me_subpel_quality(int me_subpel_quality)`
`int`	`me_threshold()` Motion estimation threshold below which no motion estimation is performed, but instead the user specified motion vectors are used.
`avcodec.AVCodecContext`	`me_threshold(int me_threshold)`
`int`	`min_prediction_order()` - encoding: Set by user.
`avcodec.AVCodecContext`	`min_prediction_order(int min_prediction_order)`
`int`	`misc_bits()`
`avcodec.AVCodecContext`	`misc_bits(int misc_bits)`
`int`	`mpeg_quant()` 0-> h263 quant 1-> mpeg quant - encoding: Set by user.
`avcodec.AVCodecContext`	`mpeg_quant(int mpeg_quant)`
`int`	`mv_bits()`
`avcodec.AVCodecContext`	`mv_bits(int mv_bits)`
`int`	`mv0_threshold()` Note: Value depends upon the compare function used for fullpel ME.
`avcodec.AVCodecContext`	`mv0_threshold(int mv0_threshold)`
`int`	`noise_reduction()` noise reduction strength - encoding: Set by user.
`avcodec.AVCodecContext`	`noise_reduction(int noise_reduction)`
`int`	`nsse_weight()` noise vs.
`avcodec.AVCodecContext`	`nsse_weight(int nsse_weight)`
`Pointer`	`opaque()` Private data of the user, can be used to carry app specific stuff.
`avcodec.AVCodecContext`	`opaque(Pointer opaque)`
`int`	`p_count()`
`avcodec.AVCodecContext`	`p_count(int p_count)`
`float`	`p_masking()` p block masking (0-> disabled) - encoding: Set by user.
`avcodec.AVCodecContext`	`p_masking(float p_masking)`
`int`	`p_tex_bits()`
`avcodec.AVCodecContext`	`p_tex_bits(int p_tex_bits)`
`int`	`pix_fmt()` Pixel format, see AV_PIX_FMT_xxx.
`avcodec.AVCodecContext`	`pix_fmt(int pix_fmt)`
`avutil.AVRational`	`pkt_timebase()` Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
`avcodec.AVCodecContext`	`pkt_timebase(avutil.AVRational pkt_timebase)`
`avcodec.AVPacket`	`pkt()` Deprecated. this field is not supposed to be accessed from outside lavc
`avcodec.AVCodecContext`	`pkt(avcodec.AVPacket pkt)`
`avcodec.AVCodecContext`	`position(int position)`
`int`	`pre_dia_size()` ME prepass diamond size & shape - encoding: Set by user.
`avcodec.AVCodecContext`	`pre_dia_size(int pre_dia_size)`
`int`	`pre_me()` prepass for motion estimation - encoding: Set by user.
`avcodec.AVCodecContext`	`pre_me(int pre_me)`
`int`	`prediction_method()` prediction method (needed for huffyuv) - encoding: Set by user.
`avcodec.AVCodecContext`	`prediction_method(int prediction_method)`
`Pointer`	`priv_data()`
`avcodec.AVCodecContext`	`priv_data(Pointer priv_data)`
`int`	`profile()` profile - encoding: Set by user.
`avcodec.AVCodecContext`	`profile(int profile)`
`long`	`pts_correction_last_dts()` PTS of the last frame
`avcodec.AVCodecContext`	`pts_correction_last_dts(long pts_correction_last_dts)`
`long`	`pts_correction_last_pts()` Number of incorrect DTS values so far
`avcodec.AVCodecContext`	`pts_correction_last_pts(long pts_correction_last_pts)`
`long`	`pts_correction_num_faulty_dts()` Number of incorrect PTS values so far
`avcodec.AVCodecContext`	`pts_correction_num_faulty_dts(long pts_correction_num_faulty_dts)`
`long`	`pts_correction_num_faulty_pts()` Current statistics for PTS correction.
`avcodec.AVCodecContext`	`pts_correction_num_faulty_pts(long pts_correction_num_faulty_pts)`
`float`	`qblur()` amount of qscale smoothing over time (0.0-1.0)
`avcodec.AVCodecContext`	`qblur(float qblur)`
`float`	`qcompress()` amount of qscale change between easy & hard scenes (0.0-1.0)
`avcodec.AVCodecContext`	`qcompress(float qcompress)`
`int`	`qmax()` maximum quantizer - encoding: Set by user.
`avcodec.AVCodecContext`	`qmax(int qmax)`
`int`	`qmin()` minimum quantizer - encoding: Set by user.
`avcodec.AVCodecContext`	`qmin(int qmin)`
`float`	`rc_buffer_aggressivity()`
`avcodec.AVCodecContext`	`rc_buffer_aggressivity(float rc_buffer_aggressivity)`
`int`	`rc_buffer_size()` decoder bitstream buffer size - encoding: Set by user.
`avcodec.AVCodecContext`	`rc_buffer_size(int rc_buffer_size)`
`BytePointer`	`rc_eq()` rate control equation - encoding: Set by user - decoding: unused
`int`	`rc_initial_buffer_occupancy()` Number of bits which should be loaded into the rc buffer before decoding starts.
`avcodec.AVCodecContext`	`rc_initial_buffer_occupancy(int rc_initial_buffer_occupancy)`
`float`	`rc_initial_cplx()` initial complexity for pass1 ratecontrol - encoding: Set by user.
`avcodec.AVCodecContext`	`rc_initial_cplx(float rc_initial_cplx)`
`float`	`rc_max_available_vbv_use()` Ratecontrol attempt to use, at maximum, of what can be used without an underflow.
`avcodec.AVCodecContext`	`rc_max_available_vbv_use(float rc_max_available_vbv_use)`
`int`	`rc_max_rate()` maximum bitrate - encoding: Set by user.
`avcodec.AVCodecContext`	`rc_max_rate(int rc_max_rate)`
`int`	`rc_min_rate()` minimum bitrate - encoding: Set by user.
`avcodec.AVCodecContext`	`rc_min_rate(int rc_min_rate)`
`float`	`rc_min_vbv_overflow_use()` Ratecontrol attempt to use, at least, times the amount needed to prevent a vbv overflow.
`avcodec.AVCodecContext`	`rc_min_vbv_overflow_use(float rc_min_vbv_overflow_use)`
`int`	`rc_override_count()` ratecontrol override, see RcOverride - encoding: Allocated/set/freed by user.
`avcodec.AVCodecContext`	`rc_override_count(int rc_override_count)`
`avcodec.RcOverride`	`rc_override()`
`avcodec.AVCodecContext`	`rc_override(avcodec.RcOverride rc_override)`
`float`	`rc_qmod_amp()`
`avcodec.AVCodecContext`	`rc_qmod_amp(float rc_qmod_amp)`
`int`	`rc_qmod_freq()`
`avcodec.AVCodecContext`	`rc_qmod_freq(int rc_qmod_freq)`
`float`	`rc_qsquish()` ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax.
`avcodec.AVCodecContext`	`rc_qsquish(float rc_qsquish)`
`int`	`rc_strategy()` obsolete FIXME remove
`avcodec.AVCodecContext`	`rc_strategy(int rc_strategy)`
`int`	`refcounted_frames()` If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted and are valid indefinitely.
`avcodec.AVCodecContext`	`refcounted_frames(int refcounted_frames)`
`int`	`refs()` number of reference frames - encoding: Set by user.
`avcodec.AVCodecContext`	`refs(int refs)`
`avcodec.AVCodecContext.Reget_buffer_AVCodecContext_AVFrame`	`reget_buffer()`
`avcodec.AVCodecContext`	`reget_buffer(avcodec.AVCodecContext.Reget_buffer_AVCodecContext_AVFrame reget_buffer)`
`avcodec.AVCodecContext.Release_buffer_AVCodecContext_AVFrame`	`release_buffer()`
`avcodec.AVCodecContext`	`release_buffer(avcodec.AVCodecContext.Release_buffer_AVCodecContext_AVFrame release_buffer)`
`long`	`reordered_opaque()` Deprecated. in favor of pkt_pts - encoding: unused - decoding: Set by user.
`avcodec.AVCodecContext`	`reordered_opaque(long reordered_opaque)`
`long`	`request_channel_layout()` Request decoder to use this channel layout if it can (0 for default) - encoding: unused - decoding: Set by user.
`avcodec.AVCodecContext`	`request_channel_layout(long request_channel_layout)`
`int`	`request_channels()` Deprecated. Deprecated in favor of request_channel_layout.
`avcodec.AVCodecContext`	`request_channels(int request_channels)`
`int`	`request_sample_fmt()` desired sample format - encoding: Not used.
`avcodec.AVCodecContext`	`request_sample_fmt(int request_sample_fmt)`
`avcodec.AVCodecContext.Rtp_callback_AVCodecContext_Pointer_int_int`	`rtp_callback()`
`avcodec.AVCodecContext`	`rtp_callback(avcodec.AVCodecContext.Rtp_callback_AVCodecContext_Pointer_int_int rtp_callback)`
`int`	`rtp_payload_size()`
`avcodec.AVCodecContext`	`rtp_payload_size(int rtp_payload_size)`
`avutil.AVRational`	`sample_aspect_ratio()` sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
`avcodec.AVCodecContext`	`sample_aspect_ratio(avutil.AVRational sample_aspect_ratio)`
`int`	`sample_fmt()` sample format
`avcodec.AVCodecContext`	`sample_fmt(int sample_fmt)`
`int`	`sample_rate()` samples per second
`avcodec.AVCodecContext`	`sample_rate(int sample_rate)`
`int`	`scenechange_factor()` Multiplied by qscale for each frame and added to scene_change_score.
`avcodec.AVCodecContext`	`scenechange_factor(int scenechange_factor)`
`int`	`scenechange_threshold()` scene change detection threshold 0 is default, larger means fewer detected scene changes.
`avcodec.AVCodecContext`	`scenechange_threshold(int scenechange_threshold)`
`int`	`seek_preroll()` Number of samples to skip after a discontinuity - decoding: unused - encoding: set by libavcodec
`avcodec.AVCodecContext`	`seek_preroll(int seek_preroll)`
`int`	`side_data_only_packets()` Encoding only.
`avcodec.AVCodecContext`	`side_data_only_packets(int side_data_only_packets)`
`int`	`skip_alpha()` Skip processing alpha if supported by codec.
`avcodec.AVCodecContext`	`skip_alpha(int skip_alpha)`
`int`	`skip_bottom()` Number of macroblock rows at the bottom which are skipped.
`avcodec.AVCodecContext`	`skip_bottom(int skip_bottom)`
`int`	`skip_count()`
`avcodec.AVCodecContext`	`skip_count(int skip_count)`
`int`	`skip_frame()` Skip decoding for selected frames.
`avcodec.AVCodecContext`	`skip_frame(int skip_frame)`
`int`	`skip_idct()` Skip IDCT/dequantization for selected frames.
`avcodec.AVCodecContext`	`skip_idct(int skip_idct)`
`int`	`skip_loop_filter()` Skip loop filtering for selected frames.
`avcodec.AVCodecContext`	`skip_loop_filter(int skip_loop_filter)`
`int`	`skip_top()` Number of macroblock rows at the top which are skipped.
`avcodec.AVCodecContext`	`skip_top(int skip_top)`
`int`	`slice_count()` slice count - encoding: Set by libavcodec.
`avcodec.AVCodecContext`	`slice_count(int slice_count)`
`int`	`slice_flags()` slice flags - encoding: unused - decoding: Set by user.
`avcodec.AVCodecContext`	`slice_flags(int slice_flags)`
`IntPointer`	`slice_offset()` slice offsets in the frame in bytes - encoding: Set/allocated by libavcodec.
`avcodec.AVCodecContext`	`slice_offset(IntPointer slice_offset)`
`int`	`slices()` Number of slices.
`avcodec.AVCodecContext`	`slices(int slices)`
`float`	`spatial_cplx_masking()` spatial complexity masking (0-> disabled) - encoding: Set by user.
`avcodec.AVCodecContext`	`spatial_cplx_masking(float spatial_cplx_masking)`
`BytePointer`	`stats_in()` pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed here.
`avcodec.AVCodecContext`	`stats_in(BytePointer stats_in)`
`BytePointer`	`stats_out()` pass1 encoding statistics output buffer - encoding: Set by libavcodec.
`avcodec.AVCodecContext`	`stats_out(BytePointer stats_out)`
`int`	`stream_codec_tag()` fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
`avcodec.AVCodecContext`	`stream_codec_tag(int stream_codec_tag)`
`int`	`strict_std_compliance()` strictly follow the standard (MPEG4, ...).
`avcodec.AVCodecContext`	`strict_std_compliance(int strict_std_compliance)`
`int`	`sub_charenc_mode()` Subtitles character encoding mode.
`avcodec.AVCodecContext`	`sub_charenc_mode(int sub_charenc_mode)`
`BytePointer`	`sub_charenc()` DTS of the last frame /** Character encoding of the input subtitles file.
`avcodec.AVCodecContext`	`sub_charenc(BytePointer sub_charenc)`
`int`	`subtitle_header_size()`
`avcodec.AVCodecContext`	`subtitle_header_size(int subtitle_header_size)`
`BytePointer`	`subtitle_header()` Header containing style information for text subtitles.
`avcodec.AVCodecContext`	`subtitle_header(BytePointer subtitle_header)`
`float`	`temporal_cplx_masking()` temporary complexity masking (0-> disabled) - encoding: Set by user.
`avcodec.AVCodecContext`	`temporal_cplx_masking(float temporal_cplx_masking)`
`int`	`thread_count()` thread count is used to decide how many independent tasks should be passed to execute() - encoding: Set by user.
`avcodec.AVCodecContext`	`thread_count(int thread_count)`
`Pointer`	`thread_opaque()` Deprecated. this field should not be used from outside of lavc
`avcodec.AVCodecContext`	`thread_opaque(Pointer thread_opaque)`
`int`	`thread_safe_callbacks()` Set by the client if its custom get_buffer() callback can be called synchronously from another thread, which allows faster multithreaded decoding.
`avcodec.AVCodecContext`	`thread_safe_callbacks(int thread_safe_callbacks)`
`int`	`thread_type()` Which multithreading methods to use.
`avcodec.AVCodecContext`	`thread_type(int thread_type)`
`int`	`ticks_per_frame()` For some codecs, the time base is closer to the field rate than the frame rate.
`avcodec.AVCodecContext`	`ticks_per_frame(int ticks_per_frame)`
`avutil.AVRational`	`time_base()` This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
`avcodec.AVCodecContext`	`time_base(avutil.AVRational time_base)`
`long`	`timecode_frame_start()` GOP timecode frame start number - encoding: Set by user, in non drop frame format - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
`avcodec.AVCodecContext`	`timecode_frame_start(long timecode_frame_start)`
`int`	`trellis()` trellis RD quantization - encoding: Set by user.
`avcodec.AVCodecContext`	`trellis(int trellis)`
`long`	`vbv_delay()` VBV delay coded in the last frame (in periods of a 27 MHz clock).
`avcodec.AVCodecContext`	`vbv_delay(long vbv_delay)`
`int`	`width()` picture width / height.
`avcodec.AVCodecContext`	`width(int width)`
`int`	`workaround_bugs()` Work around bugs in encoders which sometimes cannot be detected automatically.
`avcodec.AVCodecContext`	`workaround_bugs(int workaround_bugs)`
`int`	`xvmc_acceleration()` Deprecated. XvMC doesn't need it anymore.
`avcodec.AVCodecContext`	`xvmc_acceleration(int xvmc_acceleration)`

Methods inherited from class org.bytedeco.javacpp.Pointer
address, asBuffer, asByteBuffer, capacity, capacity, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, hashCode, isNull, limit, limit, memchr, memcmp, memcpy, memmove, memset, offsetof, position, put, setNull, sizeof, toString, withDeallocator, zero

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - FF_COMPRESSION_DEFAULT
```
public static final int FF_COMPRESSION_DEFAULT
```
    See Also:
    Constant Field Values
  - FF_ASPECT_EXTENDED
```
public static final int FF_ASPECT_EXTENDED
```
    See Also:
    Constant Field Values
  - FF_RC_STRATEGY_XVID
```
public static final int FF_RC_STRATEGY_XVID
```
    See Also:
    Constant Field Values
  - FF_PRED_LEFT
```
public static final int FF_PRED_LEFT
```
    See Also:
    Constant Field Values
  - FF_PRED_PLANE
```
public static final int FF_PRED_PLANE
```
    See Also:
    Constant Field Values
  - FF_PRED_MEDIAN
```
public static final int FF_PRED_MEDIAN
```
    See Also:
    Constant Field Values
  - FF_CMP_SAD
```
public static final int FF_CMP_SAD
```
    See Also:
    Constant Field Values
  - FF_CMP_SSE
```
public static final int FF_CMP_SSE
```
    See Also:
    Constant Field Values
  - FF_CMP_SATD
```
public static final int FF_CMP_SATD
```
    See Also:
    Constant Field Values
  - FF_CMP_DCT
```
public static final int FF_CMP_DCT
```
    See Also:
    Constant Field Values
  - FF_CMP_PSNR
```
public static final int FF_CMP_PSNR
```
    See Also:
    Constant Field Values
  - FF_CMP_BIT
```
public static final int FF_CMP_BIT
```
    See Also:
    Constant Field Values
  - FF_CMP_RD
```
public static final int FF_CMP_RD
```
    See Also:
    Constant Field Values
  - FF_CMP_ZERO
```
public static final int FF_CMP_ZERO
```
    See Also:
    Constant Field Values
  - FF_CMP_VSAD
```
public static final int FF_CMP_VSAD
```
    See Also:
    Constant Field Values
  - FF_CMP_VSSE
```
public static final int FF_CMP_VSSE
```
    See Also:
    Constant Field Values
  - FF_CMP_NSSE
```
public static final int FF_CMP_NSSE
```
    See Also:
    Constant Field Values
  - FF_CMP_W53
```
public static final int FF_CMP_W53
```
    See Also:
    Constant Field Values
  - FF_CMP_W97
```
public static final int FF_CMP_W97
```
    See Also:
    Constant Field Values
  - FF_CMP_DCTMAX
```
public static final int FF_CMP_DCTMAX
```
    See Also:
    Constant Field Values
  - FF_CMP_DCT264
```
public static final int FF_CMP_DCT264
```
    See Also:
    Constant Field Values
  - FF_CMP_CHROMA
```
public static final int FF_CMP_CHROMA
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_SAME
```
public static final int FF_DTG_AFD_SAME
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_4_3
```
public static final int FF_DTG_AFD_4_3
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_16_9
```
public static final int FF_DTG_AFD_16_9
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_14_9
```
public static final int FF_DTG_AFD_14_9
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_4_3_SP_14_9
```
public static final int FF_DTG_AFD_4_3_SP_14_9
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_16_9_SP_14_9
```
public static final int FF_DTG_AFD_16_9_SP_14_9
```
    See Also:
    Constant Field Values
  - FF_DTG_AFD_SP_4_3
```
public static final int FF_DTG_AFD_SP_4_3
```
    See Also:
    Constant Field Values
  - FF_DEFAULT_QUANT_BIAS
```
public static final int FF_DEFAULT_QUANT_BIAS
```
    See Also:
    Constant Field Values
  - SLICE_FLAG_CODED_ORDER
```
public static final int SLICE_FLAG_CODED_ORDER
```
    draw_horiz_band() is called in coded order instead of display
    
    See Also:
    Constant Field Values
  - SLICE_FLAG_ALLOW_FIELD
```
public static final int SLICE_FLAG_ALLOW_FIELD
```
    allow draw_horiz_band() with field slices (MPEG2 field pics)
    
    See Also:
    Constant Field Values
  - SLICE_FLAG_ALLOW_PLANE
```
public static final int SLICE_FLAG_ALLOW_PLANE
```
    allow draw_horiz_band() with 1 component at a time (SVQ1)
    
    See Also:
    Constant Field Values
  - FF_MB_DECISION_SIMPLE
```
public static final int FF_MB_DECISION_SIMPLE
```
    uses mb_cmp
    
    See Also:
    Constant Field Values
  - FF_MB_DECISION_BITS
```
public static final int FF_MB_DECISION_BITS
```
    chooses the one which needs the fewest bits
    
    See Also:
    Constant Field Values
  - FF_MB_DECISION_RD
```
public static final int FF_MB_DECISION_RD
```
    rate distortion
    
    See Also:
    Constant Field Values
  - FF_CODER_TYPE_VLC
```
public static final int FF_CODER_TYPE_VLC
```
    See Also:
    Constant Field Values
  - FF_CODER_TYPE_AC
```
public static final int FF_CODER_TYPE_AC
```
    See Also:
    Constant Field Values
  - FF_CODER_TYPE_RAW
```
public static final int FF_CODER_TYPE_RAW
```
    See Also:
    Constant Field Values
  - FF_CODER_TYPE_RLE
```
public static final int FF_CODER_TYPE_RLE
```
    See Also:
    Constant Field Values
  - FF_CODER_TYPE_DEFLATE
```
public static final int FF_CODER_TYPE_DEFLATE
```
    See Also:
    Constant Field Values
  - FF_BUG_AUTODETECT
```
public static final int FF_BUG_AUTODETECT
```
    autodetection
    
    See Also:
    Constant Field Values
  - FF_BUG_OLD_MSMPEG4
```
public static final int FF_BUG_OLD_MSMPEG4
```
    See Also:
    Constant Field Values
  - FF_BUG_XVID_ILACE
```
public static final int FF_BUG_XVID_ILACE
```
    See Also:
    Constant Field Values
  - FF_BUG_UMP4
```
public static final int FF_BUG_UMP4
```
    See Also:
    Constant Field Values
  - FF_BUG_NO_PADDING
```
public static final int FF_BUG_NO_PADDING
```
    See Also:
    Constant Field Values
  - FF_BUG_AMV
```
public static final int FF_BUG_AMV
```
    See Also:
    Constant Field Values
  - FF_BUG_AC_VLC
```
public static final int FF_BUG_AC_VLC
```
    Will be removed, libavcodec can now handle these non-compliant files by default.
    
    See Also:
    Constant Field Values
  - FF_BUG_QPEL_CHROMA
```
public static final int FF_BUG_QPEL_CHROMA
```
    See Also:
    Constant Field Values
  - FF_BUG_STD_QPEL
```
public static final int FF_BUG_STD_QPEL
```
    See Also:
    Constant Field Values
  - FF_BUG_QPEL_CHROMA2
```
public static final int FF_BUG_QPEL_CHROMA2
```
    See Also:
    Constant Field Values
  - FF_BUG_DIRECT_BLOCKSIZE
```
public static final int FF_BUG_DIRECT_BLOCKSIZE
```
    See Also:
    Constant Field Values
  - FF_BUG_EDGE
```
public static final int FF_BUG_EDGE
```
    See Also:
    Constant Field Values
  - FF_BUG_HPEL_CHROMA
```
public static final int FF_BUG_HPEL_CHROMA
```
    See Also:
    Constant Field Values
  - FF_BUG_DC_CLIP
```
public static final int FF_BUG_DC_CLIP
```
    See Also:
    Constant Field Values
  - FF_BUG_MS
```
public static final int FF_BUG_MS
```
    Work around various bugs in Microsoft's broken decoders.
    
    See Also:
    Constant Field Values
  - FF_BUG_TRUNCATED
```
public static final int FF_BUG_TRUNCATED
```
    See Also:
    Constant Field Values
  - FF_COMPLIANCE_VERY_STRICT
```
public static final int FF_COMPLIANCE_VERY_STRICT
```
    Strictly conform to an older more strict version of the spec or reference software.
    
    See Also:
    Constant Field Values
  - FF_COMPLIANCE_STRICT
```
public static final int FF_COMPLIANCE_STRICT
```
    Strictly conform to all the things in the spec no matter what consequences.
    
    See Also:
    Constant Field Values
  - FF_COMPLIANCE_NORMAL
```
public static final int FF_COMPLIANCE_NORMAL
```
    See Also:
    Constant Field Values
  - FF_COMPLIANCE_UNOFFICIAL
```
public static final int FF_COMPLIANCE_UNOFFICIAL
```
    Allow unofficial extensions
    
    See Also:
    Constant Field Values
  - FF_COMPLIANCE_EXPERIMENTAL
```
public static final int FF_COMPLIANCE_EXPERIMENTAL
```
    Allow nonstandardized experimental things.
    
    See Also:
    Constant Field Values
  - FF_EC_GUESS_MVS
```
public static final int FF_EC_GUESS_MVS
```
    See Also:
    Constant Field Values
  - FF_EC_DEBLOCK
```
public static final int FF_EC_DEBLOCK
```
    See Also:
    Constant Field Values
  - FF_EC_FAVOR_INTER
```
public static final int FF_EC_FAVOR_INTER
```
    See Also:
    Constant Field Values
  - FF_DEBUG_PICT_INFO
```
public static final int FF_DEBUG_PICT_INFO
```
    See Also:
    Constant Field Values
  - FF_DEBUG_RC
```
public static final int FF_DEBUG_RC
```
    See Also:
    Constant Field Values
  - FF_DEBUG_BITSTREAM
```
public static final int FF_DEBUG_BITSTREAM
```
    See Also:
    Constant Field Values
  - FF_DEBUG_MB_TYPE
```
public static final int FF_DEBUG_MB_TYPE
```
    See Also:
    Constant Field Values
  - FF_DEBUG_QP
```
public static final int FF_DEBUG_QP
```
    See Also:
    Constant Field Values
  - FF_DEBUG_MV
```
public static final int FF_DEBUG_MV
```
    Deprecated. this option does nothing
    
    See Also:
    Constant Field Values
  - FF_DEBUG_DCT_COEFF
```
public static final int FF_DEBUG_DCT_COEFF
```
    See Also:
    Constant Field Values
  - FF_DEBUG_SKIP
```
public static final int FF_DEBUG_SKIP
```
    See Also:
    Constant Field Values
  - FF_DEBUG_STARTCODE
```
public static final int FF_DEBUG_STARTCODE
```
    See Also:
    Constant Field Values
  - FF_DEBUG_PTS
```
public static final int FF_DEBUG_PTS
```
    See Also:
    Constant Field Values
  - FF_DEBUG_ER
```
public static final int FF_DEBUG_ER
```
    See Also:
    Constant Field Values
  - FF_DEBUG_MMCO
```
public static final int FF_DEBUG_MMCO
```
    See Also:
    Constant Field Values
  - FF_DEBUG_BUGS
```
public static final int FF_DEBUG_BUGS
```
    See Also:
    Constant Field Values
  - FF_DEBUG_VIS_QP
```
public static final int FF_DEBUG_VIS_QP
```
    only access through AVOptions from outside libavcodec
    
    See Also:
    Constant Field Values
  - FF_DEBUG_VIS_MB_TYPE
```
public static final int FF_DEBUG_VIS_MB_TYPE
```
    only access through AVOptions from outside libavcodec
    
    See Also:
    Constant Field Values
  - FF_DEBUG_BUFFERS
```
public static final int FF_DEBUG_BUFFERS
```
    See Also:
    Constant Field Values
  - FF_DEBUG_THREADS
```
public static final int FF_DEBUG_THREADS
```
    See Also:
    Constant Field Values
  - FF_DEBUG_NOMC
```
public static final int FF_DEBUG_NOMC
```
    See Also:
    Constant Field Values
  - FF_DEBUG_VIS_MV_P_FOR
```
public static final int FF_DEBUG_VIS_MV_P_FOR
```
    See Also:
    Constant Field Values
  - FF_DEBUG_VIS_MV_B_FOR
```
public static final int FF_DEBUG_VIS_MV_B_FOR
```
    See Also:
    Constant Field Values
  - FF_DEBUG_VIS_MV_B_BACK
```
public static final int FF_DEBUG_VIS_MV_B_BACK
```
    See Also:
    Constant Field Values
  - AV_EF_CRCCHECK
```
public static final int AV_EF_CRCCHECK
```
    Verify checksums embedded in the bitstream (could be of either encoded or decoded data, depending on the codec) and print an error message on mismatch. If AV_EF_EXPLODE is also set, a mismatching checksum will result in the decoder returning an error.
    
    See Also:
    Constant Field Values
  - AV_EF_BITSTREAM
```
public static final int AV_EF_BITSTREAM
```
    detect bitstream specification deviations
    
    See Also:
    Constant Field Values
  - AV_EF_BUFFER
```
public static final int AV_EF_BUFFER
```
    detect improper bitstream length
    
    See Also:
    Constant Field Values
  - AV_EF_EXPLODE
```
public static final int AV_EF_EXPLODE
```
    abort decoding on minor error detection
    
    See Also:
    Constant Field Values
  - AV_EF_IGNORE_ERR
```
public static final int AV_EF_IGNORE_ERR
```
    ignore errors and continue
    
    See Also:
    Constant Field Values
  - AV_EF_CAREFUL
```
public static final int AV_EF_CAREFUL
```
    consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
    
    See Also:
    Constant Field Values
  - AV_EF_COMPLIANT
```
public static final int AV_EF_COMPLIANT
```
    consider all spec non compliances as errors
    
    See Also:
    Constant Field Values
  - AV_EF_AGGRESSIVE
```
public static final int AV_EF_AGGRESSIVE
```
    consider things that a sane encoder should not do as an error
    
    See Also:
    Constant Field Values
  - FF_DCT_AUTO
```
public static final int FF_DCT_AUTO
```
    See Also:
    Constant Field Values
  - FF_DCT_FASTINT
```
public static final int FF_DCT_FASTINT
```
    See Also:
    Constant Field Values
  - FF_DCT_INT
```
public static final int FF_DCT_INT
```
    See Also:
    Constant Field Values
  - FF_DCT_MMX
```
public static final int FF_DCT_MMX
```
    See Also:
    Constant Field Values
  - FF_DCT_ALTIVEC
```
public static final int FF_DCT_ALTIVEC
```
    See Also:
    Constant Field Values
  - FF_DCT_FAAN
```
public static final int FF_DCT_FAAN
```
    See Also:
    Constant Field Values
  - FF_IDCT_AUTO
```
public static final int FF_IDCT_AUTO
```
    See Also:
    Constant Field Values
  - FF_IDCT_INT
```
public static final int FF_IDCT_INT
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLE
```
public static final int FF_IDCT_SIMPLE
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEMMX
```
public static final int FF_IDCT_SIMPLEMMX
```
    See Also:
    Constant Field Values
  - FF_IDCT_ARM
```
public static final int FF_IDCT_ARM
```
    See Also:
    Constant Field Values
  - FF_IDCT_ALTIVEC
```
public static final int FF_IDCT_ALTIVEC
```
    See Also:
    Constant Field Values
  - FF_IDCT_SH4
```
public static final int FF_IDCT_SH4
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEARM
```
public static final int FF_IDCT_SIMPLEARM
```
    See Also:
    Constant Field Values
  - FF_IDCT_IPP
```
public static final int FF_IDCT_IPP
```
    See Also:
    Constant Field Values
  - FF_IDCT_XVIDMMX
```
public static final int FF_IDCT_XVIDMMX
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEARMV5TE
```
public static final int FF_IDCT_SIMPLEARMV5TE
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEARMV6
```
public static final int FF_IDCT_SIMPLEARMV6
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEVIS
```
public static final int FF_IDCT_SIMPLEVIS
```
    See Also:
    Constant Field Values
  - FF_IDCT_FAAN
```
public static final int FF_IDCT_FAAN
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLENEON
```
public static final int FF_IDCT_SIMPLENEON
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEALPHA
```
public static final int FF_IDCT_SIMPLEALPHA
```
    See Also:
    Constant Field Values
  - FF_IDCT_SIMPLEAUTO
```
public static final int FF_IDCT_SIMPLEAUTO
```
    See Also:
    Constant Field Values
  - FF_THREAD_FRAME
```
public static final int FF_THREAD_FRAME
```
    Decode more than one frame at once
    
    See Also:
    Constant Field Values
  - FF_THREAD_SLICE
```
public static final int FF_THREAD_SLICE
```
    Decode more than one part of a single frame at once
    
    See Also:
    Constant Field Values
  - FF_PROFILE_UNKNOWN
```
public static final int FF_PROFILE_UNKNOWN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_RESERVED
```
public static final int FF_PROFILE_RESERVED
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_MAIN
```
public static final int FF_PROFILE_AAC_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_LOW
```
public static final int FF_PROFILE_AAC_LOW
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_SSR
```
public static final int FF_PROFILE_AAC_SSR
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_LTP
```
public static final int FF_PROFILE_AAC_LTP
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_HE
```
public static final int FF_PROFILE_AAC_HE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_HE_V2
```
public static final int FF_PROFILE_AAC_HE_V2
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_LD
```
public static final int FF_PROFILE_AAC_LD
```
    See Also:
    Constant Field Values
  - FF_PROFILE_AAC_ELD
```
public static final int FF_PROFILE_AAC_ELD
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_AAC_LOW
```
public static final int FF_PROFILE_MPEG2_AAC_LOW
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_AAC_HE
```
public static final int FF_PROFILE_MPEG2_AAC_HE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_DTS
```
public static final int FF_PROFILE_DTS
```
    See Also:
    Constant Field Values
  - FF_PROFILE_DTS_ES
```
public static final int FF_PROFILE_DTS_ES
```
    See Also:
    Constant Field Values
  - FF_PROFILE_DTS_96_24
```
public static final int FF_PROFILE_DTS_96_24
```
    See Also:
    Constant Field Values
  - FF_PROFILE_DTS_HD_HRA
```
public static final int FF_PROFILE_DTS_HD_HRA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_DTS_HD_MA
```
public static final int FF_PROFILE_DTS_HD_MA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_422
```
public static final int FF_PROFILE_MPEG2_422
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_HIGH
```
public static final int FF_PROFILE_MPEG2_HIGH
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_SS
```
public static final int FF_PROFILE_MPEG2_SS
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_SNR_SCALABLE
```
public static final int FF_PROFILE_MPEG2_SNR_SCALABLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_MAIN
```
public static final int FF_PROFILE_MPEG2_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG2_SIMPLE
```
public static final int FF_PROFILE_MPEG2_SIMPLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_CONSTRAINED
```
public static final int FF_PROFILE_H264_CONSTRAINED
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_INTRA
```
public static final int FF_PROFILE_H264_INTRA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_BASELINE
```
public static final int FF_PROFILE_H264_BASELINE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_CONSTRAINED_BASELINE
```
public static final int FF_PROFILE_H264_CONSTRAINED_BASELINE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_MAIN
```
public static final int FF_PROFILE_H264_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_EXTENDED
```
public static final int FF_PROFILE_H264_EXTENDED
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH
```
public static final int FF_PROFILE_H264_HIGH
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_10
```
public static final int FF_PROFILE_H264_HIGH_10
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_10_INTRA
```
public static final int FF_PROFILE_H264_HIGH_10_INTRA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_422
```
public static final int FF_PROFILE_H264_HIGH_422
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_422_INTRA
```
public static final int FF_PROFILE_H264_HIGH_422_INTRA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_444
```
public static final int FF_PROFILE_H264_HIGH_444
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_444_PREDICTIVE
```
public static final int FF_PROFILE_H264_HIGH_444_PREDICTIVE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_HIGH_444_INTRA
```
public static final int FF_PROFILE_H264_HIGH_444_INTRA
```
    See Also:
    Constant Field Values
  - FF_PROFILE_H264_CAVLC_444
```
public static final int FF_PROFILE_H264_CAVLC_444
```
    See Also:
    Constant Field Values
  - FF_PROFILE_VC1_SIMPLE
```
public static final int FF_PROFILE_VC1_SIMPLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_VC1_MAIN
```
public static final int FF_PROFILE_VC1_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_VC1_COMPLEX
```
public static final int FF_PROFILE_VC1_COMPLEX
```
    See Also:
    Constant Field Values
  - FF_PROFILE_VC1_ADVANCED
```
public static final int FF_PROFILE_VC1_ADVANCED
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_SIMPLE
```
public static final int FF_PROFILE_MPEG4_SIMPLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_SIMPLE_SCALABLE
```
public static final int FF_PROFILE_MPEG4_SIMPLE_SCALABLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_CORE
```
public static final int FF_PROFILE_MPEG4_CORE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_MAIN
```
public static final int FF_PROFILE_MPEG4_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_N_BIT
```
public static final int FF_PROFILE_MPEG4_N_BIT
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_SCALABLE_TEXTURE
```
public static final int FF_PROFILE_MPEG4_SCALABLE_TEXTURE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION
```
public static final int FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE
```
public static final int FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_HYBRID
```
public static final int FF_PROFILE_MPEG4_HYBRID
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_ADVANCED_REAL_TIME
```
public static final int FF_PROFILE_MPEG4_ADVANCED_REAL_TIME
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_CORE_SCALABLE
```
public static final int FF_PROFILE_MPEG4_CORE_SCALABLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_ADVANCED_CODING
```
public static final int FF_PROFILE_MPEG4_ADVANCED_CODING
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_ADVANCED_CORE
```
public static final int FF_PROFILE_MPEG4_ADVANCED_CORE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE
```
public static final int FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_SIMPLE_STUDIO
```
public static final int FF_PROFILE_MPEG4_SIMPLE_STUDIO
```
    See Also:
    Constant Field Values
  - FF_PROFILE_MPEG4_ADVANCED_SIMPLE
```
public static final int FF_PROFILE_MPEG4_ADVANCED_SIMPLE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0
```
public static final int FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0
```
    See Also:
    Constant Field Values
  - FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1
```
public static final int FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1
```
    See Also:
    Constant Field Values
  - FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION
```
public static final int FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION
```
    See Also:
    Constant Field Values
  - FF_PROFILE_JPEG2000_DCINEMA_2K
```
public static final int FF_PROFILE_JPEG2000_DCINEMA_2K
```
    See Also:
    Constant Field Values
  - FF_PROFILE_JPEG2000_DCINEMA_4K
```
public static final int FF_PROFILE_JPEG2000_DCINEMA_4K
```
    See Also:
    Constant Field Values
  - FF_PROFILE_HEVC_MAIN
```
public static final int FF_PROFILE_HEVC_MAIN
```
    See Also:
    Constant Field Values
  - FF_PROFILE_HEVC_MAIN_10
```
public static final int FF_PROFILE_HEVC_MAIN_10
```
    See Also:
    Constant Field Values
  - FF_PROFILE_HEVC_MAIN_STILL_PICTURE
```
public static final int FF_PROFILE_HEVC_MAIN_STILL_PICTURE
```
    See Also:
    Constant Field Values
  - FF_PROFILE_HEVC_REXT
```
public static final int FF_PROFILE_HEVC_REXT
```
    See Also:
    Constant Field Values
  - FF_LEVEL_UNKNOWN
```
public static final int FF_LEVEL_UNKNOWN
```
    See Also:
    Constant Field Values
  - FF_SUB_CHARENC_MODE_DO_NOTHING
```
public static final int FF_SUB_CHARENC_MODE_DO_NOTHING
```
    do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
    
    See Also:
    Constant Field Values
  - FF_SUB_CHARENC_MODE_AUTOMATIC
```
public static final int FF_SUB_CHARENC_MODE_AUTOMATIC
```
    libavcodec will select the mode itself
    
    See Also:
    Constant Field Values
  - FF_SUB_CHARENC_MODE_PRE_DECODER
```
public static final int FF_SUB_CHARENC_MODE_PRE_DECODER
```
    the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
    
    See Also:
    Constant Field Values
- Constructor Detail
  - avcodec.AVCodecContext
```
public avcodec.AVCodecContext()
```
  - avcodec.AVCodecContext
```
public avcodec.AVCodecContext(int size)
```
  - avcodec.AVCodecContext
```
public avcodec.AVCodecContext(Pointer p)
```
- Method Detail
  - position
```
public avcodec.AVCodecContext position(int position)
```
    Overrides:
    
    position in class Pointer
  - av_class
```
public avutil.AVClass av_class()
```
    information on struct for av_log - set by avcodec_alloc_context3
  - log_level_offset
```
public int log_level_offset()
```
  - log_level_offset
```
public avcodec.AVCodecContext log_level_offset(int log_level_offset)
```
  - codec_type
```
public int codec_type()
```
  - codec_type
```
public avcodec.AVCodecContext codec_type(int codec_type)
```
  - codec
```
public avcodec.AVCodec codec()
```
  - codec_name
```
@Deprecated
public byte codec_name(int i)
```
    Deprecated. this field is not used for anything in libavcodec
  - codec_name
```
public avcodec.AVCodecContext codec_name(int i,
                                byte codec_name)
```
  - codec_name
```
@Deprecated
public BytePointer codec_name()
```
    Deprecated.
  - codec_id
```
public int codec_id()
```
  - codec_id
```
public avcodec.AVCodecContext codec_id(int codec_id)
```
  - codec_tag
```
public int codec_tag()
```
    fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). This is used to work around some encoder bugs. A demuxer should set this to what is stored in the field used to identify the codec. If there are multiple such fields in a container then the demuxer should choose the one which maximizes the information about the used codec. If the codec tag field in a container is larger than 32 bits then the demuxer should remap the longer ID to 32 bits with a table or other structure. Alternatively a new extra_codec_tag + size could be added but for this a clear advantage must be demonstrated first. - encoding: Set by user, if not then the default based on codec_id will be used. - decoding: Set by user, will be converted to uppercase by libavcodec during init.
  - codec_tag
```
public avcodec.AVCodecContext codec_tag(int codec_tag)
```
  - stream_codec_tag
```
public int stream_codec_tag()
```
    fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). This is used to work around some encoder bugs. - encoding: unused - decoding: Set by user, will be converted to uppercase by libavcodec during init.
  - stream_codec_tag
```
public avcodec.AVCodecContext stream_codec_tag(int stream_codec_tag)
```
  - priv_data
```
public Pointer priv_data()
```
  - priv_data
```
public avcodec.AVCodecContext priv_data(Pointer priv_data)
```
  - internal
```
public avcodec.AVCodecInternal internal()
```
    Private context used for internal data. Unlike priv_data, this is not codec-specific. It is used in general libavcodec functions.
  - internal
```
public avcodec.AVCodecContext internal(avcodec.AVCodecInternal internal)
```
  - opaque
```
public Pointer opaque()
```
    Private data of the user, can be used to carry app specific stuff. - encoding: Set by user. - decoding: Set by user.
  - opaque
```
public avcodec.AVCodecContext opaque(Pointer opaque)
```
  - bit_rate
```
public int bit_rate()
```
    the average bitrate - encoding: Set by user; unused for constant quantizer encoding. - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
  - bit_rate
```
public avcodec.AVCodecContext bit_rate(int bit_rate)
```
  - bit_rate_tolerance
```
public int bit_rate_tolerance()
```
    number of bits the bitstream is allowed to diverge from the reference. the reference can be CBR (for CBR pass1) or VBR (for pass2) - encoding: Set by user; unused for constant quantizer encoding. - decoding: unused
  - bit_rate_tolerance
```
public avcodec.AVCodecContext bit_rate_tolerance(int bit_rate_tolerance)
```
  - global_quality
```
public int global_quality()
```
    Global quality for codecs which cannot change it per frame. This should be proportional to MPEG-1/2/4 qscale. - encoding: Set by user. - decoding: unused
  - global_quality
```
public avcodec.AVCodecContext global_quality(int global_quality)
```
  - compression_level
```
public int compression_level()
```
    - encoding: Set by user. - decoding: unused
  - compression_level
```
public avcodec.AVCodecContext compression_level(int compression_level)
```
  - flags
```
public int flags()
```
    CODEC_FLAG_*. - encoding: Set by user. - decoding: Set by user.
  - flags
```
public avcodec.AVCodecContext flags(int flags)
```
  - flags2
```
public int flags2()
```
    CODEC_FLAG2_* - encoding: Set by user. - decoding: Set by user.
  - flags2
```
public avcodec.AVCodecContext flags2(int flags2)
```
  - extradata
```
public BytePointer extradata()
```
    some codecs need / can use extradata like Huffman tables. mjpeg: Huffman tables rv10: additional flags mpeg4: global headers (they can be in the bitstream or here) The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger than extradata_size to avoid problems if it is read with the bitstream reader. The bytewise contents of extradata must not depend on the architecture or CPU endianness. - encoding: Set/allocated/freed by libavcodec. - decoding: Set/allocated/freed by user.
  - extradata
```
public avcodec.AVCodecContext extradata(BytePointer extradata)
```
  - extradata_size
```
public int extradata_size()
```
  - extradata_size
```
public avcodec.AVCodecContext extradata_size(int extradata_size)
```
  - time_base
```
public avutil.AVRational time_base()
```
    This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented. For fixed-fps content, timebase should be 1/framerate and timestamp increments should be identically 1. - encoding: MUST be set by user. - decoding: Set by libavcodec.
  - time_base
```
public avcodec.AVCodecContext time_base(avutil.AVRational time_base)
```
  - ticks_per_frame
```
public int ticks_per_frame()
```
    For some codecs, the time base is closer to the field rate than the frame rate. Most notably, H.264 and MPEG-2 specify time_base as half of frame duration if no telecine is used ... Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
  - ticks_per_frame
```
public avcodec.AVCodecContext ticks_per_frame(int ticks_per_frame)
```
  - delay
```
public int delay()
```
    Codec delay. Encoding: Number of frames delay there will be from the encoder input to the decoder output. (we assume the decoder matches the spec) Decoding: Number of frames delay in addition to what a standard decoder as specified in the spec would produce. Video: Number of frames the decoded output will be delayed relative to the encoded input. Audio: For encoding, this is the number of "priming" samples added by the encoder to the beginning of the stream. The decoded output will be delayed by this many samples relative to the input to the encoder (or more, if the decoder adds its own padding). The timestamps on the output packets are adjusted by the encoder so that they always refer to the first sample of the data actually contained in the packet, including any added padding. E.g. if the timebase is 1/samplerate and the timestamp of the first input sample is 0, the timestamp of the first output packet will be -delay. For decoding, this is the number of samples the decoder needs to output before the decoder's output is valid. When seeking, you should start decoding this many samples prior to your desired seek point. - encoding: Set by libavcodec. - decoding: Set by libavcodec.
  - delay
```
public avcodec.AVCodecContext delay(int delay)
```
  - width
```
public int width()
```
    picture width / height. - encoding: MUST be set by user. - decoding: May be set by the user before opening the decoder if known e.g. from the container. Some decoders will require the dimensions to be set by the caller. During decoding, the decoder may overwrite those values as required.
  - width
```
public avcodec.AVCodecContext width(int width)
```
  - height
```
public int height()
```
  - height
```
public avcodec.AVCodecContext height(int height)
```
  - coded_width
```
public int coded_width()
```
    Bitstream width / height, may be different from width/height e.g. when the decoded frame is cropped before being output or lowres is enabled. - encoding: unused - decoding: May be set by the user before opening the decoder if known e.g. from the container. During decoding, the decoder may overwrite those values as required.
  - coded_width
```
public avcodec.AVCodecContext coded_width(int coded_width)
```
  - coded_height
```
public int coded_height()
```
  - coded_height
```
public avcodec.AVCodecContext coded_height(int coded_height)
```
  - gop_size
```
public int gop_size()
```
    the number of pictures in a group of pictures, or 0 for intra_only - encoding: Set by user. - decoding: unused
  - gop_size
```
public avcodec.AVCodecContext gop_size(int gop_size)
```
  - pix_fmt
```
public int pix_fmt()
```
    Pixel format, see AV_PIX_FMT_xxx. May be set by the demuxer if known from headers. May be overridden by the decoder if it knows better. - encoding: Set by user. - decoding: Set by user if known, overridden by libavcodec if known
  - pix_fmt
```
public avcodec.AVCodecContext pix_fmt(int pix_fmt)
```
  - me_method
```
public int me_method()
```
    Motion estimation algorithm used for video coding. 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex), 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific] - encoding: MUST be set by user. - decoding: unused
  - me_method
```
public avcodec.AVCodecContext me_method(int me_method)
```
  - draw_horiz_band
```
public avcodec.AVCodecContext.Draw_horiz_band_AVCodecContext_AVFrame_IntPointer_int_int_int draw_horiz_band()
```
  - draw_horiz_band
```
public avcodec.AVCodecContext draw_horiz_band(avcodec.AVCodecContext.Draw_horiz_band_AVCodecContext_AVFrame_IntPointer_int_int_int draw_horiz_band)
```
  - get_format
```
public avcodec.AVCodecContext.Get_format_AVCodecContext_IntPointer get_format()
```
  - get_format
```
public avcodec.AVCodecContext get_format(avcodec.AVCodecContext.Get_format_AVCodecContext_IntPointer get_format)
```
  - max_b_frames
```
public int max_b_frames()
```
    maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 relative to the input. - encoding: Set by user. - decoding: unused
  - max_b_frames
```
public avcodec.AVCodecContext max_b_frames(int max_b_frames)
```
  - b_quant_factor
```
public float b_quant_factor()
```
    qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). - encoding: Set by user. - decoding: unused
  - b_quant_factor
```
public avcodec.AVCodecContext b_quant_factor(float b_quant_factor)
```
  - rc_strategy
```
public int rc_strategy()
```
    obsolete FIXME remove
  - rc_strategy
```
public avcodec.AVCodecContext rc_strategy(int rc_strategy)
```
  - b_frame_strategy
```
public int b_frame_strategy()
```
  - b_frame_strategy
```
public avcodec.AVCodecContext b_frame_strategy(int b_frame_strategy)
```
  - b_quant_offset
```
public float b_quant_offset()
```
    qscale offset between IP and B-frames - encoding: Set by user. - decoding: unused
  - b_quant_offset
```
public avcodec.AVCodecContext b_quant_offset(float b_quant_offset)
```
  - has_b_frames
```
public int has_b_frames()
```
    Size of the frame reordering buffer in the decoder. For MPEG-2 it is 1 IPB or 0 low delay IP. - encoding: Set by libavcodec. - decoding: Set by libavcodec.
  - has_b_frames
```
public avcodec.AVCodecContext has_b_frames(int has_b_frames)
```
  - mpeg_quant
```
public int mpeg_quant()
```
    0-> h263 quant 1-> mpeg quant - encoding: Set by user. - decoding: unused
  - mpeg_quant
```
public avcodec.AVCodecContext mpeg_quant(int mpeg_quant)
```
  - i_quant_factor
```
public float i_quant_factor()
```
    qscale factor between P and I-frames If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset). If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). - encoding: Set by user. - decoding: unused
  - i_quant_factor
```
public avcodec.AVCodecContext i_quant_factor(float i_quant_factor)
```
  - i_quant_offset
```
public float i_quant_offset()
```
    qscale offset between P and I-frames - encoding: Set by user. - decoding: unused
  - i_quant_offset
```
public avcodec.AVCodecContext i_quant_offset(float i_quant_offset)
```
  - lumi_masking
```
public float lumi_masking()
```
    luminance masking (0-> disabled) - encoding: Set by user. - decoding: unused
  - lumi_masking
```
public avcodec.AVCodecContext lumi_masking(float lumi_masking)
```
  - temporal_cplx_masking
```
public float temporal_cplx_masking()
```
    temporary complexity masking (0-> disabled) - encoding: Set by user. - decoding: unused
  - temporal_cplx_masking
```
public avcodec.AVCodecContext temporal_cplx_masking(float temporal_cplx_masking)
```
  - spatial_cplx_masking
```
public float spatial_cplx_masking()
```
    spatial complexity masking (0-> disabled) - encoding: Set by user. - decoding: unused
  - spatial_cplx_masking
```
public avcodec.AVCodecContext spatial_cplx_masking(float spatial_cplx_masking)
```
  - p_masking
```
public float p_masking()
```
    p block masking (0-> disabled) - encoding: Set by user. - decoding: unused
  - p_masking
```
public avcodec.AVCodecContext p_masking(float p_masking)
```
  - dark_masking
```
public float dark_masking()
```
    darkness masking (0-> disabled) - encoding: Set by user. - decoding: unused
  - dark_masking
```
public avcodec.AVCodecContext dark_masking(float dark_masking)
```
  - slice_count
```
public int slice_count()
```
    slice count - encoding: Set by libavcodec. - decoding: Set by user (or 0).
  - slice_count
```
public avcodec.AVCodecContext slice_count(int slice_count)
```
  - prediction_method
```
public int prediction_method()
```
    prediction method (needed for huffyuv) - encoding: Set by user. - decoding: unused
  - prediction_method
```
public avcodec.AVCodecContext prediction_method(int prediction_method)
```
  - slice_offset
```
public IntPointer slice_offset()
```
    slice offsets in the frame in bytes - encoding: Set/allocated by libavcodec. - decoding: Set/allocated by user (or NULL).
  - slice_offset
```
public avcodec.AVCodecContext slice_offset(IntPointer slice_offset)
```
  - sample_aspect_ratio
```
public avutil.AVRational sample_aspect_ratio()
```
    sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel. Numerator and denominator must be relatively prime and smaller than 256 for some video standards. - encoding: Set by user. - decoding: Set by libavcodec.
  - sample_aspect_ratio
```
public avcodec.AVCodecContext sample_aspect_ratio(avutil.AVRational sample_aspect_ratio)
```
  - me_cmp
```
public int me_cmp()
```
    motion estimation comparison function - encoding: Set by user. - decoding: unused
  - me_cmp
```
public avcodec.AVCodecContext me_cmp(int me_cmp)
```
  - me_sub_cmp
```
public int me_sub_cmp()
```
    subpixel motion estimation comparison function - encoding: Set by user. - decoding: unused
  - me_sub_cmp
```
public avcodec.AVCodecContext me_sub_cmp(int me_sub_cmp)
```
  - mb_cmp
```
public int mb_cmp()
```
    macroblock comparison function (not supported yet) - encoding: Set by user. - decoding: unused
  - mb_cmp
```
public avcodec.AVCodecContext mb_cmp(int mb_cmp)
```
  - ildct_cmp
```
public int ildct_cmp()
```
    interlaced DCT comparison function - encoding: Set by user. - decoding: unused
  - ildct_cmp
```
public avcodec.AVCodecContext ildct_cmp(int ildct_cmp)
```
  - dia_size
```
public int dia_size()
```
    ME diamond size & shape - encoding: Set by user. - decoding: unused
  - dia_size
```
public avcodec.AVCodecContext dia_size(int dia_size)
```
  - last_predictor_count
```
public int last_predictor_count()
```
    amount of previous MV predictors (2a+1 x 2a+1 square) - encoding: Set by user. - decoding: unused
  - last_predictor_count
```
public avcodec.AVCodecContext last_predictor_count(int last_predictor_count)
```
  - pre_me
```
public int pre_me()
```
    prepass for motion estimation - encoding: Set by user. - decoding: unused
  - pre_me
```
public avcodec.AVCodecContext pre_me(int pre_me)
```
  - me_pre_cmp
```
public int me_pre_cmp()
```
    motion estimation prepass comparison function - encoding: Set by user. - decoding: unused
  - me_pre_cmp
```
public avcodec.AVCodecContext me_pre_cmp(int me_pre_cmp)
```
  - pre_dia_size
```
public int pre_dia_size()
```
    ME prepass diamond size & shape - encoding: Set by user. - decoding: unused
  - pre_dia_size
```
public avcodec.AVCodecContext pre_dia_size(int pre_dia_size)
```
  - me_subpel_quality
```
public int me_subpel_quality()
```
    subpel ME quality - encoding: Set by user. - decoding: unused
  - me_subpel_quality
```
public avcodec.AVCodecContext me_subpel_quality(int me_subpel_quality)
```
  - dtg_active_format
```
public int dtg_active_format()
```
    DTG active format information (additional aspect ratio information only used in DVB MPEG-2 transport streams) 0 if not set. - encoding: unused - decoding: Set by decoder.
  - dtg_active_format
```
public avcodec.AVCodecContext dtg_active_format(int dtg_active_format)
```
  - me_range
```
public int me_range()
```
    maximum motion estimation search range in subpel units If 0 then no limit. - encoding: Set by user. - decoding: unused
  - me_range
```
public avcodec.AVCodecContext me_range(int me_range)
```
  - intra_quant_bias
```
public int intra_quant_bias()
```
    intra quantizer bias - encoding: Set by user. - decoding: unused
  - intra_quant_bias
```
public avcodec.AVCodecContext intra_quant_bias(int intra_quant_bias)
```
  - inter_quant_bias
```
public int inter_quant_bias()
```
    inter quantizer bias - encoding: Set by user. - decoding: unused
  - inter_quant_bias
```
public avcodec.AVCodecContext inter_quant_bias(int inter_quant_bias)
```
  - slice_flags
```
public int slice_flags()
```
    slice flags - encoding: unused - decoding: Set by user.
  - slice_flags
```
public avcodec.AVCodecContext slice_flags(int slice_flags)
```
  - xvmc_acceleration
```
@Deprecated
public int xvmc_acceleration()
```
    Deprecated. XvMC doesn't need it anymore.
    
    XVideo Motion Acceleration - encoding: forbidden - decoding: set by decoder
  - xvmc_acceleration
```
public avcodec.AVCodecContext xvmc_acceleration(int xvmc_acceleration)
```
  - mb_decision
```
public int mb_decision()
```
    macroblock decision mode - encoding: Set by user. - decoding: unused
  - mb_decision
```
public avcodec.AVCodecContext mb_decision(int mb_decision)
```
  - intra_matrix
```
public ShortPointer intra_matrix()
```
    custom intra quantization matrix - encoding: Set by user, can be NULL. - decoding: Set by libavcodec.
  - intra_matrix
```
public avcodec.AVCodecContext intra_matrix(ShortPointer intra_matrix)
```
  - inter_matrix
```
public ShortPointer inter_matrix()
```
    custom inter quantization matrix - encoding: Set by user, can be NULL. - decoding: Set by libavcodec.
  - inter_matrix
```
public avcodec.AVCodecContext inter_matrix(ShortPointer inter_matrix)
```
  - scenechange_threshold
```
public int scenechange_threshold()
```
    scene change detection threshold 0 is default, larger means fewer detected scene changes. - encoding: Set by user. - decoding: unused
  - scenechange_threshold
```
public avcodec.AVCodecContext scenechange_threshold(int scenechange_threshold)
```
  - noise_reduction
```
public int noise_reduction()
```
    noise reduction strength - encoding: Set by user. - decoding: unused
  - noise_reduction
```
public avcodec.AVCodecContext noise_reduction(int noise_reduction)
```
  - me_threshold
```
public int me_threshold()
```
    Motion estimation threshold below which no motion estimation is performed, but instead the user specified motion vectors are used. - encoding: Set by user. - decoding: unused
  - me_threshold
```
public avcodec.AVCodecContext me_threshold(int me_threshold)
```
  - mb_threshold
```
public int mb_threshold()
```
    Macroblock threshold below which the user specified macroblock types will be used. - encoding: Set by user. - decoding: unused
  - mb_threshold
```
public avcodec.AVCodecContext mb_threshold(int mb_threshold)
```
  - intra_dc_precision
```
public int intra_dc_precision()
```
    precision of the intra DC coefficient - 8 - encoding: Set by user. - decoding: unused
  - intra_dc_precision
```
public avcodec.AVCodecContext intra_dc_precision(int intra_dc_precision)
```
  - skip_top
```
public int skip_top()
```
    Number of macroblock rows at the top which are skipped. - encoding: unused - decoding: Set by user.
  - skip_top
```
public avcodec.AVCodecContext skip_top(int skip_top)
```
  - skip_bottom
```
public int skip_bottom()
```
    Number of macroblock rows at the bottom which are skipped. - encoding: unused - decoding: Set by user.
  - skip_bottom
```
public avcodec.AVCodecContext skip_bottom(int skip_bottom)
```
  - border_masking
```
public float border_masking()
```
    Border processing masking, raises the quantizer for mbs on the borders of the picture. - encoding: Set by user. - decoding: unused
  - border_masking
```
public avcodec.AVCodecContext border_masking(float border_masking)
```
  - mb_lmin
```
public int mb_lmin()
```
    minimum MB lagrange multipler - encoding: Set by user. - decoding: unused
  - mb_lmin
```
public avcodec.AVCodecContext mb_lmin(int mb_lmin)
```
  - mb_lmax
```
public int mb_lmax()
```
    maximum MB lagrange multipler - encoding: Set by user. - decoding: unused
  - mb_lmax
```
public avcodec.AVCodecContext mb_lmax(int mb_lmax)
```
  - me_penalty_compensation
```
public int me_penalty_compensation()
```
    - encoding: Set by user. - decoding: unused
  - me_penalty_compensation
```
public avcodec.AVCodecContext me_penalty_compensation(int me_penalty_compensation)
```
  - bidir_refine
```
public int bidir_refine()
```
    - encoding: Set by user. - decoding: unused
  - bidir_refine
```
public avcodec.AVCodecContext bidir_refine(int bidir_refine)
```
  - brd_scale
```
public int brd_scale()
```
    - encoding: Set by user. - decoding: unused
  - brd_scale
```
public avcodec.AVCodecContext brd_scale(int brd_scale)
```
  - keyint_min
```
public int keyint_min()
```
    minimum GOP size - encoding: Set by user. - decoding: unused
  - keyint_min
```
public avcodec.AVCodecContext keyint_min(int keyint_min)
```
  - refs
```
public int refs()
```
    number of reference frames - encoding: Set by user. - decoding: Set by lavc.
  - refs
```
public avcodec.AVCodecContext refs(int refs)
```
  - chromaoffset
```
public int chromaoffset()
```
    chroma qp offset from luma - encoding: Set by user. - decoding: unused
  - chromaoffset
```
public avcodec.AVCodecContext chromaoffset(int chromaoffset)
```
  - scenechange_factor
```
public int scenechange_factor()
```
    Multiplied by qscale for each frame and added to scene_change_score. - encoding: Set by user. - decoding: unused
  - scenechange_factor
```
public avcodec.AVCodecContext scenechange_factor(int scenechange_factor)
```
  - mv0_threshold
```
public int mv0_threshold()
```
    Note: Value depends upon the compare function used for fullpel ME. - encoding: Set by user. - decoding: unused
  - mv0_threshold
```
public avcodec.AVCodecContext mv0_threshold(int mv0_threshold)
```
  - b_sensitivity
```
public int b_sensitivity()
```
    Adjust sensitivity of b_frame_strategy 1. - encoding: Set by user. - decoding: unused
  - b_sensitivity
```
public avcodec.AVCodecContext b_sensitivity(int b_sensitivity)
```
  - color_primaries
```
public int color_primaries()
```
    Chromaticity coordinates of the source primaries. - encoding: Set by user - decoding: Set by libavcodec
  - color_primaries
```
public avcodec.AVCodecContext color_primaries(int color_primaries)
```
  - color_trc
```
public int color_trc()
```
    Color Transfer Characteristic. - encoding: Set by user - decoding: Set by libavcodec
  - color_trc
```
public avcodec.AVCodecContext color_trc(int color_trc)
```
  - colorspace
```
public int colorspace()
```
    YUV colorspace type. - encoding: Set by user - decoding: Set by libavcodec
  - colorspace
```
public avcodec.AVCodecContext colorspace(int colorspace)
```
  - color_range
```
public int color_range()
```
    MPEG vs JPEG YUV range. - encoding: Set by user - decoding: Set by libavcodec
  - color_range
```
public avcodec.AVCodecContext color_range(int color_range)
```
  - chroma_sample_location
```
public int chroma_sample_location()
```
    This defines the location of chroma samples. - encoding: Set by user - decoding: Set by libavcodec
  - chroma_sample_location
```
public avcodec.AVCodecContext chroma_sample_location(int chroma_sample_location)
```
  - slices
```
public int slices()
```
    Number of slices. Indicates number of picture subdivisions. Used for parallelized decoding. - encoding: Set by user - decoding: unused
  - slices
```
public avcodec.AVCodecContext slices(int slices)
```
  - field_order
```
public int field_order()
```
    Field order - encoding: set by libavcodec - decoding: Set by user.
  - field_order
```
public avcodec.AVCodecContext field_order(int field_order)
```
  - sample_rate
```
public int sample_rate()
```
    samples per second
  - sample_rate
```
public avcodec.AVCodecContext sample_rate(int sample_rate)
```
  - channels
```
public int channels()
```
    number of audio channels
  - channels
```
public avcodec.AVCodecContext channels(int channels)
```
  - sample_fmt
```
public int sample_fmt()
```
    sample format
  - sample_fmt
```
public avcodec.AVCodecContext sample_fmt(int sample_fmt)
```
  - frame_size
```
public int frame_size()
```
    Number of samples per channel in an audio frame. - encoding: set by libavcodec in avcodec_open2(). Each submitted frame except the last must contain exactly frame_size samples per channel. May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the frame size is not restricted. - decoding: may be set by some decoders to indicate constant frame size
  - frame_size
```
public avcodec.AVCodecContext frame_size(int frame_size)
```
  - frame_number
```
public int frame_number()
```
    Frame counter, set by libavcodec. - decoding: total number of frames returned from the decoder so far. - encoding: total number of frames passed to the encoder so far.
  - frame_number
```
public avcodec.AVCodecContext frame_number(int frame_number)
```
  - block_align
```
public int block_align()
```
    number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
  - block_align
```
public avcodec.AVCodecContext block_align(int block_align)
```
  - cutoff
```
public int cutoff()
```
    Audio cutoff bandwidth (0 means "automatic") - encoding: Set by user. - decoding: unused
  - cutoff
```
public avcodec.AVCodecContext cutoff(int cutoff)
```
  - request_channels
```
@Deprecated
public int request_channels()
```
    Deprecated. Deprecated in favor of request_channel_layout.
    
    Decoder should decode to this many channels if it can (0 for default) - encoding: unused - decoding: Set by user.
  - request_channels
```
public avcodec.AVCodecContext request_channels(int request_channels)
```
  - channel_layout
```
public long channel_layout()
```
    Audio channel layout. - encoding: set by user. - decoding: set by user, may be overwritten by libavcodec.
  - channel_layout
```
public avcodec.AVCodecContext channel_layout(long channel_layout)
```
  - request_channel_layout
```
public long request_channel_layout()
```
    Request decoder to use this channel layout if it can (0 for default) - encoding: unused - decoding: Set by user.
  - request_channel_layout
```
public avcodec.AVCodecContext request_channel_layout(long request_channel_layout)
```
  - audio_service_type
```
public int audio_service_type()
```
    Type of service that the audio stream conveys. - encoding: Set by user. - decoding: Set by libavcodec.
  - audio_service_type
```
public avcodec.AVCodecContext audio_service_type(int audio_service_type)
```
  - request_sample_fmt
```
public int request_sample_fmt()
```
    desired sample format - encoding: Not used. - decoding: Set by user. Decoder will decode to this format if it can.
  - request_sample_fmt
```
public avcodec.AVCodecContext request_sample_fmt(int request_sample_fmt)
```
  - get_buffer
```
public avcodec.AVCodecContext.Get_buffer_AVCodecContext_AVFrame get_buffer()
```
  - get_buffer
```
public avcodec.AVCodecContext get_buffer(avcodec.AVCodecContext.Get_buffer_AVCodecContext_AVFrame get_buffer)
```
  - release_buffer
```
public avcodec.AVCodecContext.Release_buffer_AVCodecContext_AVFrame release_buffer()
```
  - release_buffer
```
public avcodec.AVCodecContext release_buffer(avcodec.AVCodecContext.Release_buffer_AVCodecContext_AVFrame release_buffer)
```
  - reget_buffer
```
public avcodec.AVCodecContext.Reget_buffer_AVCodecContext_AVFrame reget_buffer()
```
  - reget_buffer
```
public avcodec.AVCodecContext reget_buffer(avcodec.AVCodecContext.Reget_buffer_AVCodecContext_AVFrame reget_buffer)
```
  - get_buffer2
```
public avcodec.AVCodecContext.Get_buffer2_AVCodecContext_AVFrame_int get_buffer2()
```
  - get_buffer2
```
public avcodec.AVCodecContext get_buffer2(avcodec.AVCodecContext.Get_buffer2_AVCodecContext_AVFrame_int get_buffer2)
```
  - refcounted_frames
```
public int refcounted_frames()
```
    If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted and are valid indefinitely. The caller must free them with av_frame_unref() when they are not needed anymore. Otherwise, the decoded frames must not be freed by the caller and are only valid until the next decode call. - encoding: unused - decoding: set by the caller before avcodec_open2().
  - refcounted_frames
```
public avcodec.AVCodecContext refcounted_frames(int refcounted_frames)
```
  - qcompress
```
public float qcompress()
```
    amount of qscale change between easy & hard scenes (0.0-1.0)
  - qcompress
```
public avcodec.AVCodecContext qcompress(float qcompress)
```
  - qblur
```
public float qblur()
```
    amount of qscale smoothing over time (0.0-1.0)
  - qblur
```
public avcodec.AVCodecContext qblur(float qblur)
```
  - qmin
```
public int qmin()
```
    minimum quantizer - encoding: Set by user. - decoding: unused
  - qmin
```
public avcodec.AVCodecContext qmin(int qmin)
```
  - qmax
```
public int qmax()
```
    maximum quantizer - encoding: Set by user. - decoding: unused
  - qmax
```
public avcodec.AVCodecContext qmax(int qmax)
```
  - max_qdiff
```
public int max_qdiff()
```
    maximum quantizer difference between frames - encoding: Set by user. - decoding: unused
  - max_qdiff
```
public avcodec.AVCodecContext max_qdiff(int max_qdiff)
```
  - rc_qsquish
```
public float rc_qsquish()
```
    ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax. - encoding: Set by user. - decoding: unused
  - rc_qsquish
```
public avcodec.AVCodecContext rc_qsquish(float rc_qsquish)
```
  - rc_qmod_amp
```
public float rc_qmod_amp()
```
  - rc_qmod_amp
```
public avcodec.AVCodecContext rc_qmod_amp(float rc_qmod_amp)
```
  - rc_qmod_freq
```
public int rc_qmod_freq()
```
  - rc_qmod_freq
```
public avcodec.AVCodecContext rc_qmod_freq(int rc_qmod_freq)
```
  - rc_buffer_size
```
public int rc_buffer_size()
```
    decoder bitstream buffer size - encoding: Set by user. - decoding: unused
  - rc_buffer_size
```
public avcodec.AVCodecContext rc_buffer_size(int rc_buffer_size)
```
  - rc_override_count
```
public int rc_override_count()
```
    ratecontrol override, see RcOverride - encoding: Allocated/set/freed by user. - decoding: unused
  - rc_override_count
```
public avcodec.AVCodecContext rc_override_count(int rc_override_count)
```
  - rc_override
```
public avcodec.RcOverride rc_override()
```
  - rc_override
```
public avcodec.AVCodecContext rc_override(avcodec.RcOverride rc_override)
```
  - rc_eq
```
public BytePointer rc_eq()
```
    rate control equation - encoding: Set by user - decoding: unused
  - rc_max_rate
```
public int rc_max_rate()
```
    maximum bitrate - encoding: Set by user. - decoding: Set by libavcodec.
  - rc_max_rate
```
public avcodec.AVCodecContext rc_max_rate(int rc_max_rate)
```
  - rc_min_rate
```
public int rc_min_rate()
```
    minimum bitrate - encoding: Set by user. - decoding: unused
  - rc_min_rate
```
public avcodec.AVCodecContext rc_min_rate(int rc_min_rate)
```
  - rc_buffer_aggressivity
```
public float rc_buffer_aggressivity()
```
  - rc_buffer_aggressivity
```
public avcodec.AVCodecContext rc_buffer_aggressivity(float rc_buffer_aggressivity)
```
  - rc_initial_cplx
```
public float rc_initial_cplx()
```
    initial complexity for pass1 ratecontrol - encoding: Set by user. - decoding: unused
  - rc_initial_cplx
```
public avcodec.AVCodecContext rc_initial_cplx(float rc_initial_cplx)
```
  - rc_max_available_vbv_use
```
public float rc_max_available_vbv_use()
```
    Ratecontrol attempt to use, at maximum, of what can be used without an underflow. - encoding: Set by user. - decoding: unused.
  - rc_max_available_vbv_use
```
public avcodec.AVCodecContext rc_max_available_vbv_use(float rc_max_available_vbv_use)
```
  - rc_min_vbv_overflow_use
```
public float rc_min_vbv_overflow_use()
```
    Ratecontrol attempt to use, at least, times the amount needed to prevent a vbv overflow. - encoding: Set by user. - decoding: unused.
  - rc_min_vbv_overflow_use
```
public avcodec.AVCodecContext rc_min_vbv_overflow_use(float rc_min_vbv_overflow_use)
```
  - rc_initial_buffer_occupancy
```
public int rc_initial_buffer_occupancy()
```
    Number of bits which should be loaded into the rc buffer before decoding starts. - encoding: Set by user. - decoding: unused
  - rc_initial_buffer_occupancy
```
public avcodec.AVCodecContext rc_initial_buffer_occupancy(int rc_initial_buffer_occupancy)
```
  - coder_type
```
public int coder_type()
```
    coder type - encoding: Set by user. - decoding: unused
  - coder_type
```
public avcodec.AVCodecContext coder_type(int coder_type)
```
  - context_model
```
public int context_model()
```
    context model - encoding: Set by user. - decoding: unused
  - context_model
```
public avcodec.AVCodecContext context_model(int context_model)
```
  - lmin
```
public int lmin()
```
    minimum Lagrange multiplier - encoding: Set by user. - decoding: unused
  - lmin
```
public avcodec.AVCodecContext lmin(int lmin)
```
  - lmax
```
public int lmax()
```
    maximum Lagrange multiplier - encoding: Set by user. - decoding: unused
  - lmax
```
public avcodec.AVCodecContext lmax(int lmax)
```
  - frame_skip_threshold
```
public int frame_skip_threshold()
```
    frame skip threshold - encoding: Set by user. - decoding: unused
  - frame_skip_threshold
```
public avcodec.AVCodecContext frame_skip_threshold(int frame_skip_threshold)
```
  - frame_skip_factor
```
public int frame_skip_factor()
```
    frame skip factor - encoding: Set by user. - decoding: unused
  - frame_skip_factor
```
public avcodec.AVCodecContext frame_skip_factor(int frame_skip_factor)
```
  - frame_skip_exp
```
public int frame_skip_exp()
```
    frame skip exponent - encoding: Set by user. - decoding: unused
  - frame_skip_exp
```
public avcodec.AVCodecContext frame_skip_exp(int frame_skip_exp)
```
  - frame_skip_cmp
```
public int frame_skip_cmp()
```
    frame skip comparison function - encoding: Set by user. - decoding: unused
  - frame_skip_cmp
```
public avcodec.AVCodecContext frame_skip_cmp(int frame_skip_cmp)
```
  - trellis
```
public int trellis()
```
    trellis RD quantization - encoding: Set by user. - decoding: unused
  - trellis
```
public avcodec.AVCodecContext trellis(int trellis)
```
  - min_prediction_order
```
public int min_prediction_order()
```
    - encoding: Set by user. - decoding: unused
  - min_prediction_order
```
public avcodec.AVCodecContext min_prediction_order(int min_prediction_order)
```
  - max_prediction_order
```
public int max_prediction_order()
```
    - encoding: Set by user. - decoding: unused
  - max_prediction_order
```
public avcodec.AVCodecContext max_prediction_order(int max_prediction_order)
```
  - timecode_frame_start
```
public long timecode_frame_start()
```
    GOP timecode frame start number - encoding: Set by user, in non drop frame format - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
  - timecode_frame_start
```
public avcodec.AVCodecContext timecode_frame_start(long timecode_frame_start)
```
  - rtp_callback
```
public avcodec.AVCodecContext.Rtp_callback_AVCodecContext_Pointer_int_int rtp_callback()
```
  - rtp_callback
```
public avcodec.AVCodecContext rtp_callback(avcodec.AVCodecContext.Rtp_callback_AVCodecContext_Pointer_int_int rtp_callback)
```
  - rtp_payload_size
```
public int rtp_payload_size()
```
  - rtp_payload_size
```
public avcodec.AVCodecContext rtp_payload_size(int rtp_payload_size)
```
  - mv_bits
```
public int mv_bits()
```
  - mv_bits
```
public avcodec.AVCodecContext mv_bits(int mv_bits)
```
  - header_bits
```
public int header_bits()
```
  - header_bits
```
public avcodec.AVCodecContext header_bits(int header_bits)
```
  - i_tex_bits
```
public int i_tex_bits()
```
  - i_tex_bits
```
public avcodec.AVCodecContext i_tex_bits(int i_tex_bits)
```
  - p_tex_bits
```
public int p_tex_bits()
```
  - p_tex_bits
```
public avcodec.AVCodecContext p_tex_bits(int p_tex_bits)
```
  - i_count
```
public int i_count()
```
  - i_count
```
public avcodec.AVCodecContext i_count(int i_count)
```
  - p_count
```
public int p_count()
```
  - p_count
```
public avcodec.AVCodecContext p_count(int p_count)
```
  - skip_count
```
public int skip_count()
```
  - skip_count
```
public avcodec.AVCodecContext skip_count(int skip_count)
```
  - misc_bits
```
public int misc_bits()
```
  - misc_bits
```
public avcodec.AVCodecContext misc_bits(int misc_bits)
```
  - frame_bits
```
public int frame_bits()
```
    number of bits used for the previously encoded frame - encoding: Set by libavcodec. - decoding: unused
  - frame_bits
```
public avcodec.AVCodecContext frame_bits(int frame_bits)
```
  - stats_out
```
public BytePointer stats_out()
```
    pass1 encoding statistics output buffer - encoding: Set by libavcodec. - decoding: unused
  - stats_out
```
public avcodec.AVCodecContext stats_out(BytePointer stats_out)
```
  - stats_in
```
public BytePointer stats_in()
```
    pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed here. - encoding: Allocated/set/freed by user. - decoding: unused
  - stats_in
```
public avcodec.AVCodecContext stats_in(BytePointer stats_in)
```
  - workaround_bugs
```
public int workaround_bugs()
```
    Work around bugs in encoders which sometimes cannot be detected automatically. - encoding: Set by user - decoding: Set by user
  - workaround_bugs
```
public avcodec.AVCodecContext workaround_bugs(int workaround_bugs)
```
  - strict_std_compliance
```
public int strict_std_compliance()
```
    strictly follow the standard (MPEG4, ...). - encoding: Set by user. - decoding: Set by user. Setting this to STRICT or higher means the encoder and decoder will generally do stupid things, whereas setting it to unofficial or lower will mean the encoder might produce output that is not supported by all spec-compliant decoders. Decoders don't differentiate between normal, unofficial and experimental (that is, they always try to decode things when they can) unless they are explicitly asked to behave stupidly (=strictly conform to the specs)
  - strict_std_compliance
```
public avcodec.AVCodecContext strict_std_compliance(int strict_std_compliance)
```
  - error_concealment
```
public int error_concealment()
```
    error concealment flags - encoding: unused - decoding: Set by user.
  - error_concealment
```
public avcodec.AVCodecContext error_concealment(int error_concealment)
```
  - debug
```
public int debug()
```
    debug - encoding: Set by user. - decoding: Set by user.
  - debug
```
public avcodec.AVCodecContext debug(int debug)
```
  - debug_mv
```
public int debug_mv()
```
    debug Code outside libavcodec should access this field using AVOptions - encoding: Set by user. - decoding: Set by user.
  - debug_mv
```
public avcodec.AVCodecContext debug_mv(int debug_mv)
```
  - err_recognition
```
public int err_recognition()
```
    Error recognition; may misdetect some more or less valid parts as errors. - encoding: unused - decoding: Set by user.
  - err_recognition
```
public avcodec.AVCodecContext err_recognition(int err_recognition)
```
  - reordered_opaque
```
public long reordered_opaque()
```
    Deprecated. in favor of pkt_pts - encoding: unused - decoding: Set by user.
    
    opaque 64bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
  - reordered_opaque
```
public avcodec.AVCodecContext reordered_opaque(long reordered_opaque)
```
  - hwaccel
```
public avcodec.AVHWAccel hwaccel()
```
    Hardware accelerator in use - encoding: unused. - decoding: Set by libavcodec
  - hwaccel
```
public avcodec.AVCodecContext hwaccel(avcodec.AVHWAccel hwaccel)
```
  - hwaccel_context
```
public Pointer hwaccel_context()
```
    Hardware accelerator context. For some hardware accelerators, a global context needs to be provided by the user. In that case, this holds display-dependent data FFmpeg cannot instantiate itself. Please refer to the FFmpeg HW accelerator documentation to know how to fill this is. e.g. for VA API, this is a struct vaapi_context. - encoding: unused - decoding: Set by user
  - hwaccel_context
```
public avcodec.AVCodecContext hwaccel_context(Pointer hwaccel_context)
```
  - error
```
public long error(int i)
```
    error - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR. - decoding: unused
  - error
```
public avcodec.AVCodecContext error(int i,
                           long error)
```
  - error
```
public LongPointer error()
```
  - dct_algo
```
public int dct_algo()
```
    DCT algorithm, see FF_DCT_* below - encoding: Set by user. - decoding: unused
  - dct_algo
```
public avcodec.AVCodecContext dct_algo(int dct_algo)
```
  - idct_algo
```
public int idct_algo()
```
    IDCT algorithm, see FF_IDCT_* below. - encoding: Set by user. - decoding: Set by user.
  - idct_algo
```
public avcodec.AVCodecContext idct_algo(int idct_algo)
```
  - bits_per_coded_sample
```
public int bits_per_coded_sample()
```
    bits per sample/pixel from the demuxer (needed for huffyuv). - encoding: Set by libavcodec. - decoding: Set by user.
  - bits_per_coded_sample
```
public avcodec.AVCodecContext bits_per_coded_sample(int bits_per_coded_sample)
```
  - bits_per_raw_sample
```
public int bits_per_raw_sample()
```
    Bits per sample/pixel of internal libavcodec pixel/sample format. - encoding: set by user. - decoding: set by libavcodec.
  - bits_per_raw_sample
```
public avcodec.AVCodecContext bits_per_raw_sample(int bits_per_raw_sample)
```
  - lowres
```
public int lowres()
```
    low resolution decoding, 1-> 1/2 size, 2->1/4 size - encoding: unused - decoding: Set by user. Code outside libavcodec should access this field using: av_codec_{get,set}_lowres(avctx)
  - lowres
```
public avcodec.AVCodecContext lowres(int lowres)
```
  - coded_frame
```
public avutil.AVFrame coded_frame()
```
    the picture in the bitstream - encoding: Set by libavcodec. - decoding: unused
  - coded_frame
```
public avcodec.AVCodecContext coded_frame(avutil.AVFrame coded_frame)
```
  - thread_count
```
public int thread_count()
```
    thread count is used to decide how many independent tasks should be passed to execute() - encoding: Set by user. - decoding: Set by user.
  - thread_count
```
public avcodec.AVCodecContext thread_count(int thread_count)
```
  - thread_type
```
public int thread_type()
```
    Which multithreading methods to use. Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread, so clients which cannot provide future frames should not use it. - encoding: Set by user, otherwise the default is used. - decoding: Set by user, otherwise the default is used.
  - thread_type
```
public avcodec.AVCodecContext thread_type(int thread_type)
```
  - active_thread_type
```
public int active_thread_type()
```
    Which multithreading methods are in use by the codec. - encoding: Set by libavcodec. - decoding: Set by libavcodec.
  - active_thread_type
```
public avcodec.AVCodecContext active_thread_type(int active_thread_type)
```
  - thread_safe_callbacks
```
public int thread_safe_callbacks()
```
    Set by the client if its custom get_buffer() callback can be called synchronously from another thread, which allows faster multithreaded decoding. draw_horiz_band() will be called from other threads regardless of this setting. Ignored if the default get_buffer() is used. - encoding: Set by user. - decoding: Set by user.
  - thread_safe_callbacks
```
public avcodec.AVCodecContext thread_safe_callbacks(int thread_safe_callbacks)
```
  - execute
```
public avcodec.AVCodecContext.Execute_AVCodecContext_Func_AVCodecContext_Pointer_Pointer_IntPointer_int_int execute()
```
  - execute
```
public avcodec.AVCodecContext execute(avcodec.AVCodecContext.Execute_AVCodecContext_Func_AVCodecContext_Pointer_Pointer_IntPointer_int_int execute)
```
  - execute2
```
public avcodec.AVCodecContext.Execute2_AVCodecContext_Func_AVCodecContext_Pointer_int_int_Pointer_IntPointer_int execute2()
```
  - execute2
```
public avcodec.AVCodecContext execute2(avcodec.AVCodecContext.Execute2_AVCodecContext_Func_AVCodecContext_Pointer_int_int_Pointer_IntPointer_int execute2)
```
  - thread_opaque
```
@Deprecated
public Pointer thread_opaque()
```
    Deprecated. this field should not be used from outside of lavc
  - thread_opaque
```
public avcodec.AVCodecContext thread_opaque(Pointer thread_opaque)
```
  - nsse_weight
```
public int nsse_weight()
```
    noise vs. sse weight for the nsse comparison function - encoding: Set by user. - decoding: unused
  - nsse_weight
```
public avcodec.AVCodecContext nsse_weight(int nsse_weight)
```
  - profile
```
public int profile()
```
    profile - encoding: Set by user. - decoding: Set by libavcodec.
  - profile
```
public avcodec.AVCodecContext profile(int profile)
```
  - level
```
public int level()
```
    level - encoding: Set by user. - decoding: Set by libavcodec.
  - level
```
public avcodec.AVCodecContext level(int level)
```
  - skip_loop_filter
```
public int skip_loop_filter()
```
    Skip loop filtering for selected frames. - encoding: unused - decoding: Set by user.
  - skip_loop_filter
```
public avcodec.AVCodecContext skip_loop_filter(int skip_loop_filter)
```
  - skip_idct
```
public int skip_idct()
```
    Skip IDCT/dequantization for selected frames. - encoding: unused - decoding: Set by user.
  - skip_idct
```
public avcodec.AVCodecContext skip_idct(int skip_idct)
```
  - skip_frame
```
public int skip_frame()
```
    Skip decoding for selected frames. - encoding: unused - decoding: Set by user.
  - skip_frame
```
public avcodec.AVCodecContext skip_frame(int skip_frame)
```
  - subtitle_header
```
public BytePointer subtitle_header()
```
    Header containing style information for text subtitles. For SUBTITLE_ASS subtitle type, it should contain the whole ASS [Script Info] and [V4+ Styles] section, plus the [Events] line and the Format line following. It shouldn't include any Dialogue line. - encoding: Set/allocated/freed by user (before avcodec_open2()) - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
  - subtitle_header
```
public avcodec.AVCodecContext subtitle_header(BytePointer subtitle_header)
```
  - subtitle_header_size
```
public int subtitle_header_size()
```
  - subtitle_header_size
```
public avcodec.AVCodecContext subtitle_header_size(int subtitle_header_size)
```
  - error_rate
```
@Deprecated
public int error_rate()
```
    Deprecated. use the 'error_rate' private AVOption of the mpegvideo encoders
  - error_rate
```
public avcodec.AVCodecContext error_rate(int error_rate)
```
  - pkt
```
@Deprecated
public avcodec.AVPacket pkt()
```
    Deprecated. this field is not supposed to be accessed from outside lavc
  - pkt
```
public avcodec.AVCodecContext pkt(avcodec.AVPacket pkt)
```
  - vbv_delay
```
public long vbv_delay()
```
    VBV delay coded in the last frame (in periods of a 27 MHz clock). Used for compliant TS muxing. - encoding: Set by libavcodec. - decoding: unused.
  - vbv_delay
```
public avcodec.AVCodecContext vbv_delay(long vbv_delay)
```
  - side_data_only_packets
```
public int side_data_only_packets()
```
    Encoding only. Allow encoders to output packets that do not contain any encoded data, only side data. Some encoders need to output such packets, e.g. to update some stream parameters at the end of encoding. All callers are strongly recommended to set this option to 1 and update their code to deal with such packets, since this behaviour may become always enabled in the future (then this option will be deprecated and later removed). To avoid ABI issues when this happens, the callers should use AVOptions to set this field.
  - side_data_only_packets
```
public avcodec.AVCodecContext side_data_only_packets(int side_data_only_packets)
```
  - pkt_timebase
```
public avutil.AVRational pkt_timebase()
```
    Timebase in which pkt_dts/pts and AVPacket.dts/pts are. Code outside libavcodec should access this field using: av_codec_{get,set}_pkt_timebase(avctx) - encoding unused. - decoding set by user.
  - pkt_timebase
```
public avcodec.AVCodecContext pkt_timebase(avutil.AVRational pkt_timebase)
```
  - codec_descriptor
```
public avcodec.AVCodecDescriptor codec_descriptor()
```
    AVCodecDescriptor Code outside libavcodec should access this field using: av_codec_{get,set}_codec_descriptor(avctx) - encoding: unused. - decoding: set by libavcodec.
  - pts_correction_num_faulty_pts
```
public long pts_correction_num_faulty_pts()
```
    Current statistics for PTS correction. - decoding: maintained and used by libavcodec, not intended to be used by user apps - encoding: unused
  - pts_correction_num_faulty_pts
```
public avcodec.AVCodecContext pts_correction_num_faulty_pts(long pts_correction_num_faulty_pts)
```
  - pts_correction_num_faulty_dts
```
public long pts_correction_num_faulty_dts()
```
    Number of incorrect PTS values so far
  - pts_correction_num_faulty_dts
```
public avcodec.AVCodecContext pts_correction_num_faulty_dts(long pts_correction_num_faulty_dts)
```
  - pts_correction_last_pts
```
public long pts_correction_last_pts()
```
    Number of incorrect DTS values so far
  - pts_correction_last_pts
```
public avcodec.AVCodecContext pts_correction_last_pts(long pts_correction_last_pts)
```
  - pts_correction_last_dts
```
public long pts_correction_last_dts()
```
    PTS of the last frame
  - pts_correction_last_dts
```
public avcodec.AVCodecContext pts_correction_last_dts(long pts_correction_last_dts)
```
  - sub_charenc
```
public BytePointer sub_charenc()
```
    DTS of the last frame /** Character encoding of the input subtitles file. - decoding: set by user - encoding: unused
  - sub_charenc
```
public avcodec.AVCodecContext sub_charenc(BytePointer sub_charenc)
```
  - sub_charenc_mode
```
public int sub_charenc_mode()
```
    Subtitles character encoding mode. Formats or codecs might be adjusting this setting (if they are doing the conversion themselves for instance). - decoding: set by libavcodec - encoding: unused
  - sub_charenc_mode
```
public avcodec.AVCodecContext sub_charenc_mode(int sub_charenc_mode)
```
  - skip_alpha
```
public int skip_alpha()
```
    Skip processing alpha if supported by codec. Note that if the format uses pre-multiplied alpha (common with VP6, and recommended due to better video quality/compression) the image will look as if alpha-blended onto a black background. However for formats that do not use pre-multiplied alpha there might be serious artefacts (though e.g. libswscale currently assumes pre-multiplied alpha anyway). Code outside libavcodec should access this field using AVOptions - decoding: set by user - encoding: unused
  - skip_alpha
```
public avcodec.AVCodecContext skip_alpha(int skip_alpha)
```
  - seek_preroll
```
public int seek_preroll()
```
    Number of samples to skip after a discontinuity - decoding: unused - encoding: set by libavcodec
  - seek_preroll
```
public avcodec.AVCodecContext seek_preroll(int seek_preroll)
```
  - chroma_intra_matrix
```
public ShortPointer chroma_intra_matrix()
```
    custom intra quantization matrix Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix() - encoding: Set by user, can be NULL. - decoding: unused.
  - chroma_intra_matrix
```
public avcodec.AVCodecContext chroma_intra_matrix(ShortPointer chroma_intra_matrix)
```

Class avcodec.AVCodecContext

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.Pointer

Methods inherited from class java.lang.Object

Field Detail

FF_COMPRESSION_DEFAULT

FF_ASPECT_EXTENDED

FF_RC_STRATEGY_XVID

FF_PRED_LEFT

FF_PRED_PLANE

FF_PRED_MEDIAN

FF_CMP_SAD

FF_CMP_SSE

FF_CMP_SATD

FF_CMP_DCT

FF_CMP_PSNR

FF_CMP_BIT

FF_CMP_RD

FF_CMP_ZERO

FF_CMP_VSAD

FF_CMP_VSSE

FF_CMP_NSSE

FF_CMP_W53

FF_CMP_W97

FF_CMP_DCTMAX

FF_CMP_DCT264

FF_CMP_CHROMA

FF_DTG_AFD_SAME

FF_DTG_AFD_4_3

FF_DTG_AFD_16_9

FF_DTG_AFD_14_9

FF_DTG_AFD_4_3_SP_14_9

FF_DTG_AFD_16_9_SP_14_9

FF_DTG_AFD_SP_4_3

FF_DEFAULT_QUANT_BIAS

SLICE_FLAG_CODED_ORDER

SLICE_FLAG_ALLOW_FIELD

SLICE_FLAG_ALLOW_PLANE

FF_MB_DECISION_SIMPLE

FF_MB_DECISION_BITS

FF_MB_DECISION_RD

FF_CODER_TYPE_VLC

FF_CODER_TYPE_AC

FF_CODER_TYPE_RAW

FF_CODER_TYPE_RLE

FF_CODER_TYPE_DEFLATE

FF_BUG_AUTODETECT

FF_BUG_OLD_MSMPEG4

FF_BUG_XVID_ILACE

FF_BUG_UMP4

FF_BUG_NO_PADDING

FF_BUG_AMV

FF_BUG_AC_VLC

FF_BUG_QPEL_CHROMA

FF_BUG_STD_QPEL

FF_BUG_QPEL_CHROMA2

FF_BUG_DIRECT_BLOCKSIZE

FF_BUG_EDGE

FF_BUG_HPEL_CHROMA

FF_BUG_DC_CLIP

FF_BUG_MS

FF_BUG_TRUNCATED

FF_COMPLIANCE_VERY_STRICT

FF_COMPLIANCE_STRICT

FF_COMPLIANCE_NORMAL

FF_COMPLIANCE_UNOFFICIAL

FF_COMPLIANCE_EXPERIMENTAL

FF_EC_GUESS_MVS

FF_EC_DEBLOCK

FF_EC_FAVOR_INTER

FF_DEBUG_PICT_INFO

FF_DEBUG_RC

FF_DEBUG_BITSTREAM

FF_DEBUG_MB_TYPE

FF_DEBUG_QP