av_frame_get_buffer: Do not fail when the channel layout is unknown
[ffmpeg.git] / libavutil / frame.c
1 /*
2  *
3  * This file is part of FFmpeg.
4  *
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.
9  *
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.
14  *
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
18  */
19
20 #include "channel_layout.h"
21 #include "avassert.h"
22 #include "buffer.h"
23 #include "common.h"
24 #include "dict.h"
25 #include "frame.h"
26 #include "imgutils.h"
27 #include "mem.h"
28 #include "samplefmt.h"
29
30 #define MAKE_ACCESSORS(str, name, type, field) \
31     type av_##name##_get_##field(const str *s) { return s->field; } \
32     void av_##name##_set_##field(str *s, type v) { s->field = v; }
33
34 MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)
35 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)
36 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)
37 MAKE_ACCESSORS(AVFrame, frame, int64_t, channel_layout)
38 MAKE_ACCESSORS(AVFrame, frame, int,     channels)
39 MAKE_ACCESSORS(AVFrame, frame, int,     sample_rate)
40 MAKE_ACCESSORS(AVFrame, frame, AVDictionary *, metadata)
41 MAKE_ACCESSORS(AVFrame, frame, int,     decode_error_flags)
42 MAKE_ACCESSORS(AVFrame, frame, int,     pkt_size)
43
44 #define CHECK_CHANNELS_CONSISTENCY(frame) \
45     av_assert2(!(frame)->channel_layout || \
46                (frame)->channels == \
47                av_get_channel_layout_nb_channels((frame)->channel_layout))
48
49 AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame) {return &frame->metadata;};
50
51 int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
52 {
53     av_buffer_unref(&f->qp_table_buf);
54
55     f->qp_table_buf = buf;
56
57     f->qscale_table = buf->data;
58     f->qstride      = stride;
59     f->qscale_type  = qp_type;
60
61     return 0;
62 }
63
64 int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type)
65 {
66     *stride = f->qstride;
67     *type   = f->qscale_type;
68
69     if (!f->qp_table_buf)
70         return NULL;
71
72     return f->qp_table_buf->data;
73 }
74
75 static void get_frame_defaults(AVFrame *frame)
76 {
77     if (frame->extended_data != frame->data)
78         av_freep(&frame->extended_data);
79
80     memset(frame, 0, sizeof(*frame));
81
82     frame->pts                   =
83     frame->pkt_dts               =
84     frame->pkt_pts               = AV_NOPTS_VALUE;
85     av_frame_set_best_effort_timestamp(frame, AV_NOPTS_VALUE);
86     av_frame_set_pkt_duration         (frame, 0);
87     av_frame_set_pkt_pos              (frame, -1);
88     av_frame_set_pkt_size             (frame, -1);
89     frame->key_frame           = 1;
90     frame->sample_aspect_ratio = (AVRational){ 0, 1 };
91     frame->format              = -1; /* unknown */
92     frame->extended_data       = frame->data;
93 }
94
95 AVFrame *av_frame_alloc(void)
96 {
97     AVFrame *frame = av_mallocz(sizeof(*frame));
98
99     if (!frame)
100         return NULL;
101
102     frame->extended_data = NULL;
103     get_frame_defaults(frame);
104
105     return frame;
106 }
107
108 void av_frame_free(AVFrame **frame)
109 {
110     if (!frame || !*frame)
111         return;
112
113     av_frame_unref(*frame);
114     av_freep(frame);
115 }
116
117 static int get_video_buffer(AVFrame *frame, int align)
118 {
119     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
120     int ret, i;
121
122     if (!desc)
123         return AVERROR(EINVAL);
124
125     if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
126         return ret;
127
128     if (!frame->linesize[0]) {
129         for(i=1; i<=align; i+=i) {
130             ret = av_image_fill_linesizes(frame->linesize, frame->format,
131                                           FFALIGN(frame->width, i));
132             if (ret < 0)
133                 return ret;
134             if (!(frame->linesize[0] & (align-1)))
135                 break;
136         }
137
138         for (i = 0; i < 4 && frame->linesize[i]; i++)
139             frame->linesize[i] = FFALIGN(frame->linesize[i], align);
140     }
141
142     for (i = 0; i < 4 && frame->linesize[i]; i++) {
143         int h = FFALIGN(frame->height, 32);
144         if (i == 1 || i == 2)
145             h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);
146
147         frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 16);
148         if (!frame->buf[i])
149             goto fail;
150
151         frame->data[i] = frame->buf[i]->data;
152     }
153     if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
154         av_buffer_unref(&frame->buf[1]);
155         frame->buf[1] = av_buffer_alloc(1024);
156         if (!frame->buf[1])
157             goto fail;
158         frame->data[1] = frame->buf[1]->data;
159     }
160
161     frame->extended_data = frame->data;
162
163     return 0;
164 fail:
165     av_frame_unref(frame);
166     return AVERROR(ENOMEM);
167 }
168
169 static int get_audio_buffer(AVFrame *frame, int align)
170 {
171     int channels = frame->channels;
172     int planar   = av_sample_fmt_is_planar(frame->format);
173     int planes   = planar ? channels : 1;
174     int ret, i;
175
176     CHECK_CHANNELS_CONSISTENCY(frame);
177     if (!frame->linesize[0]) {
178         ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
179                                          frame->nb_samples, frame->format,
180                                          align);
181         if (ret < 0)
182             return ret;
183     }
184
185     if (planes > AV_NUM_DATA_POINTERS) {
186         frame->extended_data = av_mallocz(planes *
187                                           sizeof(*frame->extended_data));
188         frame->extended_buf  = av_mallocz((planes - AV_NUM_DATA_POINTERS) *
189                                           sizeof(*frame->extended_buf));
190         if (!frame->extended_data || !frame->extended_buf) {
191             av_freep(&frame->extended_data);
192             av_freep(&frame->extended_buf);
193             return AVERROR(ENOMEM);
194         }
195         frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
196     } else
197         frame->extended_data = frame->data;
198
199     for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
200         frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
201         if (!frame->buf[i]) {
202             av_frame_unref(frame);
203             return AVERROR(ENOMEM);
204         }
205         frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
206     }
207     for (i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
208         frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
209         if (!frame->extended_buf[i]) {
210             av_frame_unref(frame);
211             return AVERROR(ENOMEM);
212         }
213         frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
214     }
215     return 0;
216
217 }
218
219 int av_frame_get_buffer(AVFrame *frame, int align)
220 {
221     if (frame->format < 0)
222         return AVERROR(EINVAL);
223
224     if (frame->width > 0 && frame->height > 0)
225         return get_video_buffer(frame, align);
226     else if (frame->nb_samples > 0 && (frame->channel_layout || frame->channels > 0))
227         return get_audio_buffer(frame, align);
228
229     return AVERROR(EINVAL);
230 }
231
232 int av_frame_ref(AVFrame *dst, AVFrame *src)
233 {
234     int i, ret = 0;
235
236     dst->format         = src->format;
237     dst->width          = src->width;
238     dst->height         = src->height;
239     dst->channels       = src->channels;
240     dst->channel_layout = src->channel_layout;
241     dst->nb_samples     = src->nb_samples;
242
243     ret = av_frame_copy_props(dst, src);
244     if (ret < 0)
245         return ret;
246
247     /* duplicate the frame data if it's not refcounted */
248     if (!src->buf[0]) {
249         ret = av_frame_get_buffer(dst, 32);
250         if (ret < 0)
251             return ret;
252
253         if (src->nb_samples) {
254             int ch = src->channels;
255             CHECK_CHANNELS_CONSISTENCY(src);
256             av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
257                             dst->nb_samples, ch, dst->format);
258         } else {
259             av_image_copy(dst->data, dst->linesize, src->data, src->linesize,
260                           dst->format, dst->width, dst->height);
261         }
262         return 0;
263     }
264
265     /* ref the buffers */
266     for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
267         if (!src->buf[i])
268             continue;
269         dst->buf[i] = av_buffer_ref(src->buf[i]);
270         if (!dst->buf[i]) {
271             ret = AVERROR(ENOMEM);
272             goto fail;
273         }
274     }
275
276     if (src->extended_buf) {
277         dst->extended_buf = av_mallocz(sizeof(*dst->extended_buf) *
278                                        src->nb_extended_buf);
279         if (!dst->extended_buf) {
280             ret = AVERROR(ENOMEM);
281             goto fail;
282         }
283         dst->nb_extended_buf = src->nb_extended_buf;
284
285         for (i = 0; i < src->nb_extended_buf; i++) {
286             dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
287             if (!dst->extended_buf[i]) {
288                 ret = AVERROR(ENOMEM);
289                 goto fail;
290             }
291         }
292     }
293
294     /* duplicate extended data */
295     if (src->extended_data != src->data) {
296         int ch = src->channels;
297
298         if (!ch) {
299             ret = AVERROR(EINVAL);
300             goto fail;
301         }
302         CHECK_CHANNELS_CONSISTENCY(src);
303
304         dst->extended_data = av_malloc(sizeof(*dst->extended_data) * ch);
305         if (!dst->extended_data) {
306             ret = AVERROR(ENOMEM);
307             goto fail;
308         }
309         memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
310     } else
311         dst->extended_data = dst->data;
312
313     memcpy(dst->data,     src->data,     sizeof(src->data));
314     memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
315
316     return 0;
317
318 fail:
319     av_frame_unref(dst);
320     return ret;
321 }
322
323 AVFrame *av_frame_clone(AVFrame *src)
324 {
325     AVFrame *ret = av_frame_alloc();
326
327     if (!ret)
328         return NULL;
329
330     if (av_frame_ref(ret, src) < 0)
331         av_frame_free(&ret);
332
333     return ret;
334 }
335
336 void av_frame_unref(AVFrame *frame)
337 {
338     int i;
339
340     for (i = 0; i < frame->nb_side_data; i++) {
341         av_freep(&frame->side_data[i]->data);
342         av_dict_free(&frame->side_data[i]->metadata);
343         av_freep(&frame->side_data[i]);
344     }
345     av_freep(&frame->side_data);
346
347     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
348         av_buffer_unref(&frame->buf[i]);
349     for (i = 0; i < frame->nb_extended_buf; i++)
350         av_buffer_unref(&frame->extended_buf[i]);
351     av_freep(&frame->extended_buf);
352     av_dict_free(&frame->metadata);
353     av_buffer_unref(&frame->qp_table_buf);
354
355     get_frame_defaults(frame);
356 }
357
358 void av_frame_move_ref(AVFrame *dst, AVFrame *src)
359 {
360     *dst = *src;
361     if (src->extended_data == src->data)
362         dst->extended_data = dst->data;
363     memset(src, 0, sizeof(*src));
364     get_frame_defaults(src);
365 }
366
367 int av_frame_is_writable(AVFrame *frame)
368 {
369     int i, ret = 1;
370
371     /* assume non-refcounted frames are not writable */
372     if (!frame->buf[0])
373         return 0;
374
375     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
376         if (frame->buf[i])
377             ret &= !!av_buffer_is_writable(frame->buf[i]);
378     for (i = 0; i < frame->nb_extended_buf; i++)
379         ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
380
381     return ret;
382 }
383
384 int av_frame_make_writable(AVFrame *frame)
385 {
386     AVFrame tmp;
387     int ret;
388
389     if (!frame->buf[0])
390         return AVERROR(EINVAL);
391
392     if (av_frame_is_writable(frame))
393         return 0;
394
395     memset(&tmp, 0, sizeof(tmp));
396     tmp.format         = frame->format;
397     tmp.width          = frame->width;
398     tmp.height         = frame->height;
399     tmp.channels       = frame->channels;
400     tmp.channel_layout = frame->channel_layout;
401     tmp.nb_samples     = frame->nb_samples;
402     ret = av_frame_get_buffer(&tmp, 32);
403     if (ret < 0)
404         return ret;
405
406     if (tmp.nb_samples) {
407         int ch = tmp.channels;
408         CHECK_CHANNELS_CONSISTENCY(&tmp);
409         av_samples_copy(tmp.extended_data, frame->extended_data, 0, 0,
410                         frame->nb_samples, ch, frame->format);
411     } else {
412         av_image_copy(tmp.data, tmp.linesize, frame->data, frame->linesize,
413                       frame->format, frame->width, frame->height);
414     }
415
416     ret = av_frame_copy_props(&tmp, frame);
417     if (ret < 0) {
418         av_frame_unref(&tmp);
419         return ret;
420     }
421
422     av_frame_unref(frame);
423
424     *frame = tmp;
425     if (tmp.data == tmp.extended_data)
426         frame->extended_data = frame->data;
427
428     return 0;
429 }
430
431 int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
432 {
433     int i;
434
435     dst->key_frame           = src->key_frame;
436     dst->pict_type           = src->pict_type;
437     dst->sample_aspect_ratio = src->sample_aspect_ratio;
438     dst->pts                 = src->pts;
439     dst->repeat_pict         = src->repeat_pict;
440     dst->interlaced_frame    = src->interlaced_frame;
441     dst->top_field_first     = src->top_field_first;
442     dst->palette_has_changed = src->palette_has_changed;
443     dst->sample_rate         = src->sample_rate;
444     dst->opaque              = src->opaque;
445 #if FF_API_AVFRAME_LAVC
446     dst->type                = src->type;
447 #endif
448     dst->pkt_pts             = src->pkt_pts;
449     dst->pkt_dts             = src->pkt_dts;
450     dst->pkt_pos             = src->pkt_pos;
451     dst->pkt_size            = src->pkt_size;
452     dst->pkt_duration        = src->pkt_duration;
453     dst->reordered_opaque    = src->reordered_opaque;
454     dst->quality             = src->quality;
455     dst->best_effort_timestamp = src->best_effort_timestamp;
456     dst->coded_picture_number = src->coded_picture_number;
457     dst->display_picture_number = src->display_picture_number;
458     dst->decode_error_flags  = src->decode_error_flags;
459
460     av_dict_copy(&dst->metadata, src->metadata, 0);
461
462     memcpy(dst->error, src->error, sizeof(dst->error));
463
464     for (i = 0; i < src->nb_side_data; i++) {
465         const AVFrameSideData *sd_src = src->side_data[i];
466         AVFrameSideData *sd_dst = av_frame_new_side_data(dst, sd_src->type,
467                                                          sd_src->size);
468         if (!sd_dst) {
469             for (i = 0; i < dst->nb_side_data; i++) {
470                 av_freep(&dst->side_data[i]->data);
471                 av_freep(&dst->side_data[i]);
472                 av_dict_free(&dst->side_data[i]->metadata);
473             }
474             av_freep(&dst->side_data);
475             return AVERROR(ENOMEM);
476         }
477         memcpy(sd_dst->data, sd_src->data, sd_src->size);
478         av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
479     }
480
481     dst->qscale_table = NULL;
482     dst->qstride      = 0;
483     dst->qscale_type  = 0;
484     if (src->qp_table_buf) {
485         dst->qp_table_buf = av_buffer_ref(src->qp_table_buf);
486         if (dst->qp_table_buf) {
487             dst->qscale_table = dst->qp_table_buf->data;
488             dst->qstride      = src->qstride;
489             dst->qscale_type  = src->qscale_type;
490         }
491     }
492
493     return 0;
494 }
495
496 AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)
497 {
498     uint8_t *data;
499     int planes, i;
500
501     if (frame->nb_samples) {
502         int channels = frame->channels;
503         if (!channels)
504             return NULL;
505         CHECK_CHANNELS_CONSISTENCY(frame);
506         planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
507     } else
508         planes = 4;
509
510     if (plane < 0 || plane >= planes || !frame->extended_data[plane])
511         return NULL;
512     data = frame->extended_data[plane];
513
514     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
515         AVBufferRef *buf = frame->buf[i];
516         if (data >= buf->data && data < buf->data + buf->size)
517             return buf;
518     }
519     for (i = 0; i < frame->nb_extended_buf; i++) {
520         AVBufferRef *buf = frame->extended_buf[i];
521         if (data >= buf->data && data < buf->data + buf->size)
522             return buf;
523     }
524     return NULL;
525 }
526
527 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
528                                         enum AVFrameSideDataType type,
529                                         int size)
530 {
531     AVFrameSideData *ret, **tmp;
532
533     if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
534         return NULL;
535
536     tmp = av_realloc(frame->side_data,
537                      (frame->nb_side_data + 1) * sizeof(*frame->side_data));
538     if (!tmp)
539         return NULL;
540     frame->side_data = tmp;
541
542     ret = av_mallocz(sizeof(*ret));
543     if (!ret)
544         return NULL;
545
546     ret->data = av_malloc(size);
547     if (!ret->data) {
548         av_freep(&ret);
549         return NULL;
550     }
551
552     ret->size = size;
553     ret->type = type;
554
555     frame->side_data[frame->nb_side_data++] = ret;
556
557     return ret;
558 }
559
560 AVFrameSideData *av_frame_get_side_data(AVFrame *frame,
561                                         enum AVFrameSideDataType type)
562 {
563     int i;
564
565     for (i = 0; i < frame->nb_side_data; i++) {
566         if (frame->side_data[i]->type == type)
567             return frame->side_data[i];
568     }
569     return NULL;
570 }