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