#include "imgutils.h"
#include "mem.h"
#include "samplefmt.h"
-
-
-static AVFrameSideData *frame_new_side_data(AVFrame *frame,
- enum AVFrameSideDataType type,
- AVBufferRef *buf);
-
-#if FF_API_FRAME_GET_SET
-MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)
-MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)
-MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)
-MAKE_ACCESSORS(AVFrame, frame, int64_t, channel_layout)
-MAKE_ACCESSORS(AVFrame, frame, int, channels)
-MAKE_ACCESSORS(AVFrame, frame, int, sample_rate)
-MAKE_ACCESSORS(AVFrame, frame, AVDictionary *, metadata)
-MAKE_ACCESSORS(AVFrame, frame, int, decode_error_flags)
-MAKE_ACCESSORS(AVFrame, frame, int, pkt_size)
-MAKE_ACCESSORS(AVFrame, frame, enum AVColorSpace, colorspace)
-MAKE_ACCESSORS(AVFrame, frame, enum AVColorRange, color_range)
-#endif
+#include "hwcontext.h"
#define CHECK_CHANNELS_CONSISTENCY(frame) \
av_assert2(!(frame)->channel_layout || \
(frame)->channels == \
av_get_channel_layout_nb_channels((frame)->channel_layout))
-#if FF_API_FRAME_QP
-int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
-{
- av_buffer_unref(&f->qp_table_buf);
-
- f->qp_table_buf = buf;
-
-FF_DISABLE_DEPRECATION_WARNINGS
- f->qscale_table = buf->data;
- f->qstride = stride;
- f->qscale_type = qp_type;
-FF_ENABLE_DEPRECATION_WARNINGS
-
- return 0;
-}
-
-int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type)
-{
-FF_DISABLE_DEPRECATION_WARNINGS
- *stride = f->qstride;
- *type = f->qscale_type;
-FF_ENABLE_DEPRECATION_WARNINGS
-
- if (!f->qp_table_buf)
- return NULL;
-
- return f->qp_table_buf->data;
-}
-#endif
-
+#if FF_API_COLORSPACE_NAME
const char *av_get_colorspace_name(enum AVColorSpace val)
{
static const char * const name[] = {
return NULL;
return name[val];
}
-
+#endif
static void get_frame_defaults(AVFrame *frame)
{
if (frame->extended_data != frame->data)
frame->pts =
frame->pkt_dts = AV_NOPTS_VALUE;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
- frame->pkt_pts = AV_NOPTS_VALUE;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
frame->best_effort_timestamp = AV_NOPTS_VALUE;
frame->pkt_duration = 0;
frame->pkt_pos = -1;
static int get_video_buffer(AVFrame *frame, int align)
{
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
- int ret, i;
+ int ret, i, padded_height, total_size;
+ int plane_padding = FFMAX(16 + 16/*STRIDE_ALIGN*/, align);
+ ptrdiff_t linesizes[4];
+ size_t sizes[4];
if (!desc)
return AVERROR(EINVAL);
frame->linesize[i] = FFALIGN(frame->linesize[i], align);
}
- for (i = 0; i < 4 && frame->linesize[i]; i++) {
- int h = FFALIGN(frame->height, 32);
- if (i == 1 || i == 2)
- h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
+ for (i = 0; i < 4; i++)
+ linesizes[i] = frame->linesize[i];
- frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 16 + 16/*STRIDE_ALIGN*/ - 1);
- if (!frame->buf[i])
- goto fail;
+ padded_height = FFALIGN(frame->height, 32);
+ if ((ret = av_image_fill_plane_sizes(sizes, frame->format,
+ padded_height, linesizes)) < 0)
+ return ret;
- frame->data[i] = frame->buf[i]->data;
+ total_size = 4*plane_padding;
+ for (i = 0; i < 4; i++) {
+ if (sizes[i] > INT_MAX - total_size)
+ return AVERROR(EINVAL);
+ total_size += sizes[i];
}
- if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
- av_buffer_unref(&frame->buf[1]);
- frame->buf[1] = av_buffer_alloc(AVPALETTE_SIZE);
- if (!frame->buf[1])
- goto fail;
- frame->data[1] = frame->buf[1]->data;
+
+ frame->buf[0] = av_buffer_alloc(total_size);
+ if (!frame->buf[0]) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ if ((ret = av_image_fill_pointers(frame->data, frame->format, padded_height,
+ frame->buf[0]->data, frame->linesize)) < 0)
+ goto fail;
+
+ for (i = 1; i < 4; i++) {
+ if (frame->data[i])
+ frame->data[i] += i * plane_padding;
}
frame->extended_data = frame->data;
return 0;
fail:
av_frame_unref(frame);
- return AVERROR(ENOMEM);
+ return ret;
}
static int get_audio_buffer(AVFrame *frame, int align)
static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
{
- int i;
+ int ret, i;
dst->key_frame = src->key_frame;
dst->pict_type = src->pict_type;
dst->palette_has_changed = src->palette_has_changed;
dst->sample_rate = src->sample_rate;
dst->opaque = src->opaque;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
- dst->pkt_pts = src->pkt_pts;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
dst->pkt_dts = src->pkt_dts;
dst->pkt_pos = src->pkt_pos;
dst->pkt_size = src->pkt_size;
av_dict_copy(&dst->metadata, src->metadata, 0);
-#if FF_API_ERROR_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- memcpy(dst->error, src->error, sizeof(dst->error));
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
for (i = 0; i < src->nb_side_data; i++) {
const AVFrameSideData *sd_src = src->side_data[i];
AVFrameSideData *sd_dst;
}
memcpy(sd_dst->data, sd_src->data, sd_src->size);
} else {
- sd_dst = frame_new_side_data(dst, sd_src->type, av_buffer_ref(sd_src->buf));
+ AVBufferRef *ref = av_buffer_ref(sd_src->buf);
+ sd_dst = av_frame_new_side_data_from_buf(dst, sd_src->type, ref);
if (!sd_dst) {
+ av_buffer_unref(&ref);
wipe_side_data(dst);
return AVERROR(ENOMEM);
}
av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
}
-#if FF_API_FRAME_QP
-FF_DISABLE_DEPRECATION_WARNINGS
- dst->qscale_table = NULL;
- dst->qstride = 0;
- dst->qscale_type = 0;
- av_buffer_unref(&dst->qp_table_buf);
- if (src->qp_table_buf) {
- dst->qp_table_buf = av_buffer_ref(src->qp_table_buf);
- if (dst->qp_table_buf) {
- dst->qscale_table = dst->qp_table_buf->data;
- dst->qstride = src->qstride;
- dst->qscale_type = src->qscale_type;
- }
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
- av_buffer_unref(&dst->opaque_ref);
- av_buffer_unref(&dst->private_ref);
- if (src->opaque_ref) {
- dst->opaque_ref = av_buffer_ref(src->opaque_ref);
- if (!dst->opaque_ref)
- return AVERROR(ENOMEM);
- }
- if (src->private_ref) {
- dst->private_ref = av_buffer_ref(src->private_ref);
- if (!dst->private_ref)
- return AVERROR(ENOMEM);
- }
- return 0;
+ ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
+ ret |= av_buffer_replace(&dst->private_ref, src->private_ref);
+ return ret;
}
int av_frame_ref(AVFrame *dst, const AVFrame *src)
ret = frame_copy_props(dst, src, 0);
if (ret < 0)
- return ret;
+ goto fail;
/* duplicate the frame data if it's not refcounted */
if (!src->buf[0]) {
- ret = av_frame_get_buffer(dst, 32);
+ ret = av_frame_get_buffer(dst, 0);
if (ret < 0)
- return ret;
+ goto fail;
ret = av_frame_copy(dst, src);
if (ret < 0)
- av_frame_unref(dst);
+ goto fail;
- return ret;
+ return 0;
}
/* ref the buffers */
av_buffer_unref(&frame->extended_buf[i]);
av_freep(&frame->extended_buf);
av_dict_free(&frame->metadata);
-#if FF_API_FRAME_QP
- av_buffer_unref(&frame->qp_table_buf);
-#endif
av_buffer_unref(&frame->hw_frames_ctx);
tmp.channels = frame->channels;
tmp.channel_layout = frame->channel_layout;
tmp.nb_samples = frame->nb_samples;
- ret = av_frame_get_buffer(&tmp, 32);
+
+ if (frame->hw_frames_ctx)
+ ret = av_hwframe_get_buffer(frame->hw_frames_ctx, &tmp, 0);
+ else
+ ret = av_frame_get_buffer(&tmp, 0);
if (ret < 0)
return ret;
return NULL;
}
-static AVFrameSideData *frame_new_side_data(AVFrame *frame,
- enum AVFrameSideDataType type,
- AVBufferRef *buf)
+AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
+ enum AVFrameSideDataType type,
+ AVBufferRef *buf)
{
AVFrameSideData *ret, **tmp;
return NULL;
if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
- goto fail;
+ return NULL;
tmp = av_realloc(frame->side_data,
(frame->nb_side_data + 1) * sizeof(*frame->side_data));
if (!tmp)
- goto fail;
+ return NULL;
frame->side_data = tmp;
ret = av_mallocz(sizeof(*ret));
if (!ret)
- goto fail;
+ return NULL;
ret->buf = buf;
ret->data = ret->buf->data;
frame->side_data[frame->nb_side_data++] = ret;
return ret;
-fail:
- av_buffer_unref(&buf);
- return NULL;
}
AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
enum AVFrameSideDataType type,
- int size)
+ buffer_size_t size)
{
-
- return frame_new_side_data(frame, type, av_buffer_alloc(size));
+ AVFrameSideData *ret;
+ AVBufferRef *buf = av_buffer_alloc(size);
+ ret = av_frame_new_side_data_from_buf(frame, type, buf);
+ if (!ret)
+ av_buffer_unref(&buf);
+ return ret;
}
AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
dst->height < src->height)
return AVERROR(EINVAL);
+ if (src->hw_frames_ctx || dst->hw_frames_ctx)
+ return av_hwframe_transfer_data(dst, src, 0);
+
planes = av_pix_fmt_count_planes(dst->format);
for (i = 0; i < planes; i++)
if (!dst->data[i] || !src->data[i])
{
int i;
- for (i = 0; i < frame->nb_side_data; i++) {
+ for (i = frame->nb_side_data - 1; i >= 0; i--) {
AVFrameSideData *sd = frame->side_data[i];
if (sd->type == type) {
free_side_data(&frame->side_data[i]);
switch(type) {
case AV_FRAME_DATA_PANSCAN: return "AVPanScan";
case AV_FRAME_DATA_A53_CC: return "ATSC A53 Part 4 Closed Captions";
- case AV_FRAME_DATA_STEREO3D: return "Stereoscopic 3d metadata";
+ case AV_FRAME_DATA_STEREO3D: return "Stereo 3D";
case AV_FRAME_DATA_MATRIXENCODING: return "AVMatrixEncoding";
case AV_FRAME_DATA_DOWNMIX_INFO: return "Metadata relevant to a downmix procedure";
case AV_FRAME_DATA_REPLAYGAIN: return "AVReplayGain";
case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
case AV_FRAME_DATA_GOP_TIMECODE: return "GOP timecode";
+ case AV_FRAME_DATA_S12M_TIMECODE: return "SMPTE 12-1 timecode";
+ case AV_FRAME_DATA_SPHERICAL: return "Spherical Mapping";
case AV_FRAME_DATA_ICC_PROFILE: return "ICC profile";
+ case AV_FRAME_DATA_DYNAMIC_HDR_PLUS: return "HDR Dynamic Metadata SMPTE2094-40 (HDR10+)";
+ case AV_FRAME_DATA_REGIONS_OF_INTEREST: return "Regions Of Interest";
+ case AV_FRAME_DATA_VIDEO_ENC_PARAMS: return "Video encoding parameters";
+ case AV_FRAME_DATA_SEI_UNREGISTERED: return "H.26[45] User Data Unregistered SEI message";
+ case AV_FRAME_DATA_FILM_GRAIN_PARAMS: return "Film grain parameters";
+ case AV_FRAME_DATA_DETECTION_BBOXES: return "Bounding boxes for object detection and classification";
}
return NULL;
}
int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
- if (desc->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL) && i == 1) {
+ if (desc->flags & (AV_PIX_FMT_FLAG_PAL | FF_PSEUDOPAL) && i == 1) {
offsets[i] = 0;
break;
}
projects / ffmpeg / blobdiff