3 * This file is part of FFmpeg.
5 * FFmpeg is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * FFmpeg is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with FFmpeg; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "channel_layout.h"
28 #include "samplefmt.h"
30 MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)
31 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)
32 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)
33 MAKE_ACCESSORS(AVFrame, frame, int64_t, channel_layout)
34 MAKE_ACCESSORS(AVFrame, frame, int, channels)
35 MAKE_ACCESSORS(AVFrame, frame, int, sample_rate)
36 MAKE_ACCESSORS(AVFrame, frame, AVDictionary *, metadata)
37 MAKE_ACCESSORS(AVFrame, frame, int, decode_error_flags)
38 MAKE_ACCESSORS(AVFrame, frame, int, pkt_size)
39 MAKE_ACCESSORS(AVFrame, frame, enum AVColorSpace, colorspace)
40 MAKE_ACCESSORS(AVFrame, frame, enum AVColorRange, color_range)
42 #define CHECK_CHANNELS_CONSISTENCY(frame) \
43 av_assert2(!(frame)->channel_layout || \
44 (frame)->channels == \
45 av_get_channel_layout_nb_channels((frame)->channel_layout))
47 AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame) {return &frame->metadata;};
49 int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
51 av_buffer_unref(&f->qp_table_buf);
53 f->qp_table_buf = buf;
55 f->qscale_table = buf->data;
57 f->qscale_type = qp_type;
62 int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type)
65 *type = f->qscale_type;
70 return f->qp_table_buf->data;
73 const char *av_get_colorspace_name(enum AVColorSpace val)
75 static const char *name[] = {
76 [AVCOL_SPC_RGB] = "GBR",
77 [AVCOL_SPC_BT709] = "bt709",
78 [AVCOL_SPC_FCC] = "fcc",
79 [AVCOL_SPC_BT470BG] = "bt470bg",
80 [AVCOL_SPC_SMPTE170M] = "smpte170m",
81 [AVCOL_SPC_SMPTE240M] = "smpte240m",
82 [AVCOL_SPC_YCOCG] = "YCgCo",
84 if ((unsigned)val >= FF_ARRAY_ELEMS(name))
89 static void get_frame_defaults(AVFrame *frame)
91 if (frame->extended_data != frame->data)
92 av_freep(&frame->extended_data);
94 memset(frame, 0, sizeof(*frame));
98 frame->pkt_pts = AV_NOPTS_VALUE;
99 av_frame_set_best_effort_timestamp(frame, AV_NOPTS_VALUE);
100 av_frame_set_pkt_duration (frame, 0);
101 av_frame_set_pkt_pos (frame, -1);
102 av_frame_set_pkt_size (frame, -1);
103 frame->key_frame = 1;
104 frame->sample_aspect_ratio = (AVRational){ 0, 1 };
105 frame->format = -1; /* unknown */
106 frame->extended_data = frame->data;
107 #if FF_API_AVFRAME_COLORSPACE
108 frame->color_primaries = AVCOL_PRI_UNSPECIFIED;
109 frame->color_trc = AVCOL_TRC_UNSPECIFIED;
110 frame->colorspace = AVCOL_SPC_UNSPECIFIED;
111 frame->color_range = AVCOL_RANGE_UNSPECIFIED;
112 frame->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
116 AVFrame *av_frame_alloc(void)
118 AVFrame *frame = av_mallocz(sizeof(*frame));
123 frame->extended_data = NULL;
124 get_frame_defaults(frame);
129 void av_frame_free(AVFrame **frame)
131 if (!frame || !*frame)
134 av_frame_unref(*frame);
138 static int get_video_buffer(AVFrame *frame, int align)
140 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
144 return AVERROR(EINVAL);
146 if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
149 if (!frame->linesize[0]) {
150 for(i=1; i<=align; i+=i) {
151 ret = av_image_fill_linesizes(frame->linesize, frame->format,
152 FFALIGN(frame->width, i));
155 if (!(frame->linesize[0] & (align-1)))
159 for (i = 0; i < 4 && frame->linesize[i]; i++)
160 frame->linesize[i] = FFALIGN(frame->linesize[i], align);
163 for (i = 0; i < 4 && frame->linesize[i]; i++) {
164 int h = FFALIGN(frame->height, 32);
165 if (i == 1 || i == 2)
166 h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);
168 frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 16 + 16/*STRIDE_ALIGN*/ - 1);
172 frame->data[i] = frame->buf[i]->data;
174 if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
175 av_buffer_unref(&frame->buf[1]);
176 frame->buf[1] = av_buffer_alloc(1024);
179 frame->data[1] = frame->buf[1]->data;
182 frame->extended_data = frame->data;
186 av_frame_unref(frame);
187 return AVERROR(ENOMEM);
190 static int get_audio_buffer(AVFrame *frame, int align)
193 int planar = av_sample_fmt_is_planar(frame->format);
197 if (!frame->channels)
198 frame->channels = av_get_channel_layout_nb_channels(frame->channel_layout);
200 channels = frame->channels;
201 planes = planar ? channels : 1;
203 CHECK_CHANNELS_CONSISTENCY(frame);
204 if (!frame->linesize[0]) {
205 ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
206 frame->nb_samples, frame->format,
212 if (planes > AV_NUM_DATA_POINTERS) {
213 frame->extended_data = av_mallocz_array(planes,
214 sizeof(*frame->extended_data));
215 frame->extended_buf = av_mallocz_array((planes - AV_NUM_DATA_POINTERS),
216 sizeof(*frame->extended_buf));
217 if (!frame->extended_data || !frame->extended_buf) {
218 av_freep(&frame->extended_data);
219 av_freep(&frame->extended_buf);
220 return AVERROR(ENOMEM);
222 frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
224 frame->extended_data = frame->data;
226 for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
227 frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
228 if (!frame->buf[i]) {
229 av_frame_unref(frame);
230 return AVERROR(ENOMEM);
232 frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
234 for (i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
235 frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
236 if (!frame->extended_buf[i]) {
237 av_frame_unref(frame);
238 return AVERROR(ENOMEM);
240 frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
246 int av_frame_get_buffer(AVFrame *frame, int align)
248 if (frame->format < 0)
249 return AVERROR(EINVAL);
251 if (frame->width > 0 && frame->height > 0)
252 return get_video_buffer(frame, align);
253 else if (frame->nb_samples > 0 && (frame->channel_layout || frame->channels > 0))
254 return get_audio_buffer(frame, align);
256 return AVERROR(EINVAL);
259 int av_frame_ref(AVFrame *dst, const AVFrame *src)
263 dst->format = src->format;
264 dst->width = src->width;
265 dst->height = src->height;
266 dst->channels = src->channels;
267 dst->channel_layout = src->channel_layout;
268 dst->nb_samples = src->nb_samples;
270 ret = av_frame_copy_props(dst, src);
274 /* duplicate the frame data if it's not refcounted */
276 ret = av_frame_get_buffer(dst, 32);
280 ret = av_frame_copy(dst, src);
287 /* ref the buffers */
288 for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
291 dst->buf[i] = av_buffer_ref(src->buf[i]);
293 ret = AVERROR(ENOMEM);
298 if (src->extended_buf) {
299 dst->extended_buf = av_mallocz_array(sizeof(*dst->extended_buf),
300 src->nb_extended_buf);
301 if (!dst->extended_buf) {
302 ret = AVERROR(ENOMEM);
305 dst->nb_extended_buf = src->nb_extended_buf;
307 for (i = 0; i < src->nb_extended_buf; i++) {
308 dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
309 if (!dst->extended_buf[i]) {
310 ret = AVERROR(ENOMEM);
316 /* duplicate extended data */
317 if (src->extended_data != src->data) {
318 int ch = src->channels;
321 ret = AVERROR(EINVAL);
324 CHECK_CHANNELS_CONSISTENCY(src);
326 dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
327 if (!dst->extended_data) {
328 ret = AVERROR(ENOMEM);
331 memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
333 dst->extended_data = dst->data;
335 memcpy(dst->data, src->data, sizeof(src->data));
336 memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
345 AVFrame *av_frame_clone(const AVFrame *src)
347 AVFrame *ret = av_frame_alloc();
352 if (av_frame_ref(ret, src) < 0)
358 void av_frame_unref(AVFrame *frame)
362 for (i = 0; i < frame->nb_side_data; i++) {
363 av_freep(&frame->side_data[i]->data);
364 av_dict_free(&frame->side_data[i]->metadata);
365 av_freep(&frame->side_data[i]);
367 av_freep(&frame->side_data);
369 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
370 av_buffer_unref(&frame->buf[i]);
371 for (i = 0; i < frame->nb_extended_buf; i++)
372 av_buffer_unref(&frame->extended_buf[i]);
373 av_freep(&frame->extended_buf);
374 av_dict_free(&frame->metadata);
375 av_buffer_unref(&frame->qp_table_buf);
377 get_frame_defaults(frame);
380 void av_frame_move_ref(AVFrame *dst, AVFrame *src)
383 if (src->extended_data == src->data)
384 dst->extended_data = dst->data;
385 memset(src, 0, sizeof(*src));
386 get_frame_defaults(src);
389 int av_frame_is_writable(AVFrame *frame)
393 /* assume non-refcounted frames are not writable */
397 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
399 ret &= !!av_buffer_is_writable(frame->buf[i]);
400 for (i = 0; i < frame->nb_extended_buf; i++)
401 ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
406 int av_frame_make_writable(AVFrame *frame)
412 return AVERROR(EINVAL);
414 if (av_frame_is_writable(frame))
417 memset(&tmp, 0, sizeof(tmp));
418 tmp.format = frame->format;
419 tmp.width = frame->width;
420 tmp.height = frame->height;
421 tmp.channels = frame->channels;
422 tmp.channel_layout = frame->channel_layout;
423 tmp.nb_samples = frame->nb_samples;
424 ret = av_frame_get_buffer(&tmp, 32);
428 ret = av_frame_copy(&tmp, frame);
430 av_frame_unref(&tmp);
434 ret = av_frame_copy_props(&tmp, frame);
436 av_frame_unref(&tmp);
440 av_frame_unref(frame);
443 if (tmp.data == tmp.extended_data)
444 frame->extended_data = frame->data;
449 int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
453 dst->key_frame = src->key_frame;
454 dst->pict_type = src->pict_type;
455 dst->sample_aspect_ratio = src->sample_aspect_ratio;
457 dst->repeat_pict = src->repeat_pict;
458 dst->interlaced_frame = src->interlaced_frame;
459 dst->top_field_first = src->top_field_first;
460 dst->palette_has_changed = src->palette_has_changed;
461 dst->sample_rate = src->sample_rate;
462 dst->opaque = src->opaque;
463 #if FF_API_AVFRAME_LAVC
464 dst->type = src->type;
466 dst->pkt_pts = src->pkt_pts;
467 dst->pkt_dts = src->pkt_dts;
468 dst->pkt_pos = src->pkt_pos;
469 dst->pkt_size = src->pkt_size;
470 dst->pkt_duration = src->pkt_duration;
471 dst->reordered_opaque = src->reordered_opaque;
472 dst->quality = src->quality;
473 dst->best_effort_timestamp = src->best_effort_timestamp;
474 dst->coded_picture_number = src->coded_picture_number;
475 dst->display_picture_number = src->display_picture_number;
476 dst->flags = src->flags;
477 dst->decode_error_flags = src->decode_error_flags;
478 #if FF_API_AVFRAME_COLORSPACE
479 dst->color_primaries = src->color_primaries;
480 dst->color_trc = src->color_trc;
481 dst->colorspace = src->colorspace;
482 dst->color_range = src->color_range;
483 dst->chroma_location = src->chroma_location;
486 av_dict_copy(&dst->metadata, src->metadata, 0);
488 memcpy(dst->error, src->error, sizeof(dst->error));
490 for (i = 0; i < src->nb_side_data; i++) {
491 const AVFrameSideData *sd_src = src->side_data[i];
492 AVFrameSideData *sd_dst = av_frame_new_side_data(dst, sd_src->type,
495 for (i = 0; i < dst->nb_side_data; i++) {
496 av_freep(&dst->side_data[i]->data);
497 av_dict_free(&dst->side_data[i]->metadata);
498 av_freep(&dst->side_data[i]);
500 av_freep(&dst->side_data);
501 return AVERROR(ENOMEM);
503 memcpy(sd_dst->data, sd_src->data, sd_src->size);
504 av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
507 dst->qscale_table = NULL;
509 dst->qscale_type = 0;
510 if (src->qp_table_buf) {
511 dst->qp_table_buf = av_buffer_ref(src->qp_table_buf);
512 if (dst->qp_table_buf) {
513 dst->qscale_table = dst->qp_table_buf->data;
514 dst->qstride = src->qstride;
515 dst->qscale_type = src->qscale_type;
522 AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)
527 if (frame->nb_samples) {
528 int channels = frame->channels;
531 CHECK_CHANNELS_CONSISTENCY(frame);
532 planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
536 if (plane < 0 || plane >= planes || !frame->extended_data[plane])
538 data = frame->extended_data[plane];
540 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
541 AVBufferRef *buf = frame->buf[i];
542 if (data >= buf->data && data < buf->data + buf->size)
545 for (i = 0; i < frame->nb_extended_buf; i++) {
546 AVBufferRef *buf = frame->extended_buf[i];
547 if (data >= buf->data && data < buf->data + buf->size)
553 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
554 enum AVFrameSideDataType type,
557 AVFrameSideData *ret, **tmp;
559 if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
562 tmp = av_realloc(frame->side_data,
563 (frame->nb_side_data + 1) * sizeof(*frame->side_data));
566 frame->side_data = tmp;
568 ret = av_mallocz(sizeof(*ret));
572 ret->data = av_malloc(size);
581 frame->side_data[frame->nb_side_data++] = ret;
586 AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
587 enum AVFrameSideDataType type)
591 for (i = 0; i < frame->nb_side_data; i++) {
592 if (frame->side_data[i]->type == type)
593 return frame->side_data[i];
598 static int frame_copy_video(AVFrame *dst, const AVFrame *src)
600 const uint8_t *src_data[4];
603 if (dst->width < src->width ||
604 dst->height < src->height)
605 return AVERROR(EINVAL);
607 planes = av_pix_fmt_count_planes(dst->format);
608 for (i = 0; i < planes; i++)
609 if (!dst->data[i] || !src->data[i])
610 return AVERROR(EINVAL);
612 memcpy(src_data, src->data, sizeof(src_data));
613 av_image_copy(dst->data, dst->linesize,
614 src_data, src->linesize,
615 dst->format, src->width, src->height);
620 static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
622 int planar = av_sample_fmt_is_planar(dst->format);
623 int channels = dst->channels;
624 int planes = planar ? channels : 1;
627 if (dst->nb_samples != src->nb_samples ||
628 dst->channels != src->channels ||
629 dst->channel_layout != src->channel_layout)
630 return AVERROR(EINVAL);
632 CHECK_CHANNELS_CONSISTENCY(src);
634 for (i = 0; i < planes; i++)
635 if (!dst->extended_data[i] || !src->extended_data[i])
636 return AVERROR(EINVAL);
638 av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
639 dst->nb_samples, channels, dst->format);
644 int av_frame_copy(AVFrame *dst, const AVFrame *src)
646 if (dst->format != src->format || dst->format < 0)
647 return AVERROR(EINVAL);
649 if (dst->width > 0 && dst->height > 0)
650 return frame_copy_video(dst, src);
651 else if (dst->nb_samples > 0 && dst->channel_layout)
652 return frame_copy_audio(dst, src);
654 return AVERROR(EINVAL);
657 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
661 for (i = 0; i < frame->nb_side_data; i++) {
662 AVFrameSideData *sd = frame->side_data[i];
663 if (sd->type == type) {
665 av_dict_free(&sd->metadata);
666 av_freep(&frame->side_data[i]);
667 frame->side_data[i] = frame->side_data[frame->nb_side_data - 1];
668 frame->nb_side_data--;