28 #define UNCHECKED_BITSTREAM_READER 1
64 return h &&
h->ps.sps ?
h->ps.sps->num_reorder_frames : 0;
69 int mb_x,
int mb_y,
int mb_intra,
int mb_skipped)
76 sl->
mb_xy = mb_x + mb_y *
h->mb_stride;
109 int vshift =
desc->log2_chroma_h;
110 const int field_pic =
h->picture_structure !=
PICT_FRAME;
127 offset[2] = (y >> vshift) *
src->linesize[1];
134 y,
h->picture_structure,
height);
150 h->slice_table =
NULL;
161 for (
i = 0;
i <
h->nb_slice_ctx;
i++) {
183 const int big_mb_num =
h->mb_stride * (
h->mb_height + 1);
184 const int row_mb_num = 2*
h->mb_stride*
FFMAX(
h->nb_slice_ctx, 1);
185 const int st_size = big_mb_num +
h->mb_stride;
200 h->slice_ctx[0].intra4x4_pred_mode =
h->intra4x4_pred_mode;
201 h->slice_ctx[0].mvd_table[0] =
h->mvd_table[0];
202 h->slice_ctx[0].mvd_table[1] =
h->mvd_table[1];
203 memset(
h->slice_table_base, -1,
204 st_size *
sizeof(*
h->slice_table_base));
205 h->slice_table =
h->slice_table_base +
h->mb_stride * 2 + 1;
206 for (y = 0; y <
h->mb_height; y++)
207 for (x = 0; x <
h->mb_width; x++) {
208 const int mb_xy = x + y *
h->mb_stride;
209 const int b_xy = 4 * x + 4 * y *
h->b_stride;
211 h->mb2b_xy[mb_xy] = b_xy;
212 h->mb2br_xy[mb_xy] = 8 * (
FMO ? mb_xy : (mb_xy % (2 *
h->mb_stride)));
225 int mb_array_size =
h->mb_height *
h->mb_stride;
226 int y_size = (2 *
h->mb_width + 1) * (2 *
h->mb_height + 1);
227 int c_size =
h->mb_stride * (
h->mb_height + 1);
228 int yc_size = y_size + 2 * c_size;
238 if (sl !=
h->slice_ctx) {
239 memset(er, 0,
sizeof(*er));
241 const int er_size =
h->mb_height *
h->mb_stride * (4*
sizeof(
int) + 1);
262 for (y = 0; y <
h->mb_height; y++)
263 for (x = 0; x <
h->mb_width; x++)
266 er->
mb_index2xy[
h->mb_height *
h->mb_width] = (
h->mb_height - 1) *
267 h->mb_stride +
h->mb_width;
271 for (
i = 0;
i < yc_size;
i++)
283 h->cur_chroma_format_idc = -1;
285 h->width_from_caller = avctx->
width;
286 h->height_from_caller = avctx->
height;
290 h->poc.prev_poc_msb = 1 << 16;
291 h->recovery_frame = -1;
292 h->frame_recovered = 0;
293 h->poc.prev_frame_num = -1;
294 h->sei.frame_packing.arrangement_cancel_flag = -1;
295 h->sei.unregistered.x264_build = -1;
297 h->next_outputed_poc = INT_MIN;
299 h->last_pocs[
i] = INT_MIN;
321 if (!
h->last_pic_for_ec.f)
324 for (
i = 0;
i <
h->nb_slice_ctx;
i++)
325 h->slice_ctx[
i].h264 =
h;
342 memset(
h->delayed_pic, 0,
sizeof(
h->delayed_pic));
344 h->cur_pic_ptr =
NULL;
380 if(
h->avctx->time_base.den < INT_MAX/2) {
381 h->avctx->time_base.den *= 2;
383 h->avctx->time_base.num /= 2;
390 &
h->ps, &
h->is_avc, &
h->nal_length_size,
395 "Error decoding the extradata\n");
404 if (
h->ps.sps &&
h->ps.sps->bitstream_restriction_flag &&
405 h->avctx->has_b_frames <
h->ps.sps->num_reorder_frames) {
406 h->avctx->has_b_frames =
h->ps.sps->num_reorder_frames;
416 "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
417 "Use it at your own risk\n");
430 h->poc.prev_frame_num =
431 h->poc.prev_frame_num_offset = 0;
432 h->poc.prev_poc_msb = 1<<16;
433 h->poc.prev_poc_lsb = -1;
435 h->last_pocs[
i] = INT_MIN;
443 h->next_outputed_poc = INT_MIN;
444 h->prev_interlaced_frame = 1;
447 h->poc.prev_frame_num = -1;
448 if (
h->cur_pic_ptr) {
449 h->cur_pic_ptr->reference = 0;
450 for (j=
i=0;
h->delayed_pic[
i];
i++)
451 if (
h->delayed_pic[
i] !=
h->cur_pic_ptr)
452 h->delayed_pic[j++] =
h->delayed_pic[
i];
453 h->delayed_pic[j] =
NULL;
458 h->recovery_frame = -1;
459 h->frame_recovered = 0;
460 h->current_slice = 0;
469 memset(
h->delayed_pic, 0,
sizeof(
h->delayed_pic));
476 h->cur_pic_ptr =
NULL;
482 h->context_initialized = 0;
491 for (
i = 0;
i <
h->pkt.nb_nals;
i++) {
517 first_slice != nal->
type)
520 first_slice = nal->
type;
566 h->current_slice = 0;
567 if (!
h->first_field) {
568 h->cur_pic_ptr =
NULL;
573 if (
h->nal_length_size == 4) {
574 if (buf_size > 8 &&
AV_RB32(buf) == 1 &&
AV_RB32(buf+5) > (
unsigned)buf_size) {
576 }
else if(buf_size > 3 &&
AV_RB32(buf) > 1 &&
AV_RB32(buf) <= (
unsigned)buf_size)
584 "Error splitting the input into NAL units.\n");
593 for (
i = 0;
i <
h->pkt.nb_nals;
i++) {
595 int max_slice_ctx, err;
603 h->nal_unit_type = nal->
type;
608 if ((nal->
data[1] & 0xFC) == 0x98) {
610 h->next_outputed_poc = INT_MIN;
618 h->has_recovery_point = 1;
628 if (
h->current_slice == 1) {
630 i >= nals_needed && !
h->setup_finished &&
h->cur_pic_ptr) {
632 h->setup_finished = 1;
635 if (
h->avctx->hwaccel &&
636 (ret =
h->avctx->hwaccel->start_frame(
h->avctx, buf, buf_size)) < 0)
640 max_slice_ctx = avctx->
hwaccel ? 1 :
h->nb_slice_ctx;
641 if (
h->nb_slice_ctx_queued == max_slice_ctx) {
642 if (
h->avctx->hwaccel) {
644 h->nb_slice_ctx_queued = 0;
658 h->has_recovery_point =
h->has_recovery_point ||
h->sei.recovery_point.recovery_frame_cnt != -1;
677 "SPS decoding failure, trying again with the complete NAL\n");
720 if ((ret < 0 || h->slice_ctx->er.error_occurred) &&
h->cur_pic_ptr) {
727 #if CONFIG_ERROR_RESILIENCE
743 int use_last_pic =
h->last_pic_for_ec.f->buf[0] && !sl->
ref_count[0];
769 if (
h->cur_pic_ptr && !
h->droppable &&
h->has_slice) {
774 return (ret < 0) ? ret : buf_size;
784 if (
pos + 10 > buf_size)
809 const unsigned int block_idx = y * p->
mb_width + x;
810 const unsigned int mb_xy = y * p->
mb_stride + x;
852 int cnt= buf[5]&0x1f;
858 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
867 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
882 if (!
h->avctx->hwaccel &&
883 (
out->field_poc[0] == INT_MAX ||
884 out->field_poc[1] == INT_MAX)
888 int field =
out->field_poc[0] == INT_MAX;
895 for (p = 0; p<4; p++) {
896 dst_data[p] =
f->data[p] + (field^1)*
f->linesize[p];
897 src_data[p] =
f->data[p] + field *
f->linesize[p];
898 linesizes[p] = 2*
f->linesize[p];
902 f->format,
f->width,
f->height>>1);
917 h->mb_width,
h->mb_height,
h->mb_stride, 1);
925 int *got_frame,
int buf_index)
930 h->cur_pic_ptr =
NULL;
936 !
h->delayed_pic[
i]->f->key_frame &&
937 !
h->delayed_pic[
i]->mmco_reset;
939 if (
h->delayed_pic[
i]->poc <
out->poc) {
940 out =
h->delayed_pic[
i];
944 for (
i = out_idx;
h->delayed_pic[
i];
i++)
945 h->delayed_pic[
i] =
h->delayed_pic[
i + 1];
961 int buf_size = avpkt->
size;
968 h->setup_finished = 0;
969 h->nb_slice_ctx_queued = 0;
981 &
h->ps, &
h->is_avc, &
h->nal_length_size,
984 if (
h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {
987 &
h->ps, &
h->is_avc, &
h->nal_length_size,
1002 buf_size >= 4 && !memcmp(
"Q264", buf, 4))
1009 (
h->mb_y >=
h->mb_height &&
h->mb_height)) {
1014 if (
h->next_output_pic) {
1028 #define OFFSET(x) offsetof(H264Context, x)
1029 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1032 {
"nal_length_size",
"nal_length_size",
OFFSET(nal_length_size),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
1033 {
"enable_er",
"Enable error resilience on damaged frames (unsafe)",
OFFSET(enable_er),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
VD },
1034 {
"x264_build",
"Assume this x264 version if no x264 version found in any SEI",
OFFSET(x264_build),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VD },
1058 #if CONFIG_H264_DXVA2_HWACCEL
1061 #if CONFIG_H264_D3D11VA_HWACCEL
1064 #if CONFIG_H264_D3D11VA2_HWACCEL
1067 #if CONFIG_H264_NVDEC_HWACCEL
1070 #if CONFIG_H264_VAAPI_HWACCEL
1073 #if CONFIG_H264_VDPAU_HWACCEL
1076 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
#define FF_THREAD_FRAME
Decode more than one frame at once.
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_DEBUG_GREEN_MD
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
static av_cold int init(AVCodecContext *avctx)
Context Adaptive Binary Arithmetic Coder inline functions.
#define CONFIG_ERROR_RESILIENCE
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
void ff_er_frame_end(ERContext *s)
static void fill_rectangle(int x, int y, int w, int h)
#define FF_DECODE_ERROR_DECODE_SLICES
#define AV_NUM_DATA_POINTERS
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
@ AVDISCARD_NONREF
discard all non reference
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
#define LIBAVUTIL_VERSION_INT
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
H.264 common definitions.
@ H264_NAL_AUXILIARY_SLICE
av_cold void ff_h264_decode_init_vlc(void)
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
H.264 / AVC / MPEG-4 part10 motion vector prediction.
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
H.264 parameter set handling.
void ff_h264_remove_all_refs(H264Context *h)
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
H.264 / AVC / MPEG-4 part10 codec.
static const uint8_t scan8[16 *3+3]
#define H264_MAX_PICTURE_COUNT
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
#define MAX_DELAYED_PIC_COUNT
#define PART_NOT_AVAILABLE
#define HWACCEL_DXVA2(codec)
#define HWACCEL_VDPAU(codec)
#define HWACCEL_NVDEC(codec)
#define HWACCEL_VAAPI(codec)
#define HWACCEL_D3D11VA(codec)
#define HWACCEL_D3D11VA2(codec)
static const int8_t mv[256][2]
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
static av_cold int h264_decode_end(AVCodecContext *avctx)
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
const uint16_t ff_h264_mb_sizes[4]
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init context Allocate buffers which are not shared amongst multiple threads.
static av_cold int h264_decode_init(AVCodecContext *avctx)
static int get_last_needed_nal(H264Context *h)
void ff_h264_free_tables(H264Context *h)
static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)
static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
static const AVOption h264_options[]
static int h264_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int h264_export_enc_params(AVFrame *f, H264Picture *p)
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
static int h264_init_context(AVCodecContext *avctx, H264Context *h)
static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
static int is_avcc_extradata(const uint8_t *buf, int buf_size)
static void h264_decode_flush(AVCodecContext *avctx)
static AVOnce h264_vlc_init
static void idr(H264Context *h)
instantaneous decoder refresh.
static const AVClass h264_class
void ff_h264_flush_change(H264Context *h)
static int get_consumed_bytes(int pos, int buf_size)
Return the number of bytes consumed for building the current frame.
static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, int *got_frame, int buf_index)
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
static int ff_thread_once(char *control, void(*routine)(void))
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
#define PICT_BOTTOM_FIELD
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
const AVProfile ff_h264_profiles[]
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
useful rectangle filling function
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int flags2
AV_CODEC_FLAG2_*.
int slice_flags
slice flags
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
int active_thread_type
Which multithreading methods are in use by the codec.
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int flags
AV_CODEC_FLAG_*.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
struct AVCodecInternal * internal
Private context used for internal data.
enum AVDiscard skip_frame
Skip decoding for selected frames.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
int key_frame
1 -> keyframe, 0-> not
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
AVDictionary * metadata
metadata.
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
int(* decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size)
Callback for parameter data (SPS/PPS/VPS etc).
This structure stores compressed data.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Data structure for storing block-level encoding information.
Video encoding parameters for a given frame.
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
int32_t qp
Base quantisation parameter for the frame.
uint8_t * error_status_table
void(* decode_mb)(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)
int ref_idc
H.264 only, nal_ref_idc.
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding.
int sei_recovery_frame_cnt
int mb_field_decoding_flag
int8_t ref_cache[2][5 *8]
int bipred_scratchpad_allocated
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
uint8_t * edge_emu_buffer
int top_borders_allocated[2]
uint8_t * bipred_scratchpad
uint8_t(*[2] top_borders)[(16 *3) *2]
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
int edge_emu_buffer_allocated
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
int chroma_qp_index_offset[2]
int init_qp
pic_init_qp_minus26 + 26
#define avpriv_request_sample(...)
static int ref[MAX_W *MAX_W]
static const uint8_t offset[127][2]
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
@ AV_VIDEO_ENC_PARAMS_H264
H.264 stores: