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