?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 1874684 - Part 28: Return DateDuration from DifferenceISODateTime. r=mgaudet
[gecko.git] / media / ffvpx / libavutil / frame.c
bloba3f07ca089211de913e8b43ef8e34536cdeac9b2
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "channel_layout.h"
20 #include "avassert.h"
21 #include "buffer.h"
22 #include "common.h"
23 #include "cpu.h"
24 #include "dict.h"
25 #include "frame.h"
26 #include "imgutils.h"
27 #include "mem.h"
28 #include "samplefmt.h"
29 #include "hwcontext.h"
30
31 #if FF_API_OLD_CHANNEL_LAYOUT
32 #define CHECK_CHANNELS_CONSISTENCY(frame) \
33 av_assert2(!(frame)->channel_layout || \
34 (frame)->channels == \
35 av_get_channel_layout_nb_channels((frame)->channel_layout))
36 #endif
37
38 static void get_frame_defaults(AVFrame *frame)
39 {
40 memset(frame, 0, sizeof(*frame));
41
42 frame->pts =
43 frame->pkt_dts = AV_NOPTS_VALUE;
44 frame->best_effort_timestamp = AV_NOPTS_VALUE;
45 frame->duration = 0;
46 #if FF_API_PKT_DURATION
47 FF_DISABLE_DEPRECATION_WARNINGS
48 frame->pkt_duration = 0;
49 FF_ENABLE_DEPRECATION_WARNINGS
50 #endif
51 #if FF_API_FRAME_PKT
52 FF_DISABLE_DEPRECATION_WARNINGS
53 frame->pkt_pos = -1;
54 frame->pkt_size = -1;
55 FF_ENABLE_DEPRECATION_WARNINGS
56 #endif
57 frame->time_base = (AVRational){ 0, 1 };
58 frame->sample_aspect_ratio = (AVRational){ 0, 1 };
59 frame->format = -1; /* unknown */
60 frame->extended_data = frame->data;
61 frame->color_primaries = AVCOL_PRI_UNSPECIFIED;
62 frame->color_trc = AVCOL_TRC_UNSPECIFIED;
63 frame->colorspace = AVCOL_SPC_UNSPECIFIED;
64 frame->color_range = AVCOL_RANGE_UNSPECIFIED;
65 frame->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
66 frame->flags = 0;
67 }
68
69 static void free_side_data(AVFrameSideData **ptr_sd)
70 {
71 AVFrameSideData *sd = *ptr_sd;
72
73 av_buffer_unref(&sd->buf);
74 av_dict_free(&sd->metadata);
75 av_freep(ptr_sd);
76 }
77
78 static void wipe_side_data(AVFrame *frame)
79 {
80 for (int i = 0; i < frame->nb_side_data; i++) {
81 free_side_data(&frame->side_data[i]);
82 }
83 frame->nb_side_data = 0;
84
85 av_freep(&frame->side_data);
86 }
87
88 AVFrame *av_frame_alloc(void)
89 {
90 AVFrame *frame = av_malloc(sizeof(*frame));
91
92 if (!frame)
93 return NULL;
94
95 get_frame_defaults(frame);
96
97 return frame;
98 }
99
100 void av_frame_free(AVFrame **frame)
101 {
102 if (!frame || !*frame)
103 return;
104
105 av_frame_unref(*frame);
106 av_freep(frame);
107 }
108
109 static int get_video_buffer(AVFrame *frame, int align)
110 {
111 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
112 int ret, padded_height, total_size;
113 int plane_padding = FFMAX(16 + 16/*STRIDE_ALIGN*/, align);
114 ptrdiff_t linesizes[4];
115 size_t sizes[4];
116
117 if (!desc)
118 return AVERROR(EINVAL);
119
120 if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
121 return ret;
122
123 if (!frame->linesize[0]) {
124 if (align <= 0)
125 align = 32; /* STRIDE_ALIGN. Should be av_cpu_max_align() */
126
127 for (int i = 1; i <= align; i += i) {
128 ret = av_image_fill_linesizes(frame->linesize, frame->format,
129 FFALIGN(frame->width, i));
130 if (ret < 0)
131 return ret;
132 if (!(frame->linesize[0] & (align-1)))
133 break;
134 }
135
136 for (int i = 0; i < 4 && frame->linesize[i]; i++)
137 frame->linesize[i] = FFALIGN(frame->linesize[i], align);
138 }
139
140 for (int i = 0; i < 4; i++)
141 linesizes[i] = frame->linesize[i];
142
143 padded_height = FFALIGN(frame->height, 32);
144 if ((ret = av_image_fill_plane_sizes(sizes, frame->format,
145 padded_height, linesizes)) < 0)
146 return ret;
147
148 total_size = 4*plane_padding;
149 for (int i = 0; i < 4; i++) {
150 if (sizes[i] > INT_MAX - total_size)
151 return AVERROR(EINVAL);
152 total_size += sizes[i];
153 }
154
155 frame->buf[0] = av_buffer_alloc(total_size);
156 if (!frame->buf[0]) {
157 ret = AVERROR(ENOMEM);
158 goto fail;
159 }
160
161 if ((ret = av_image_fill_pointers(frame->data, frame->format, padded_height,
162 frame->buf[0]->data, frame->linesize)) < 0)
163 goto fail;
164
165 for (int i = 1; i < 4; i++) {
166 if (frame->data[i])
167 frame->data[i] += i * plane_padding;
168 }
169
170 frame->extended_data = frame->data;
171
172 return 0;
173 fail:
174 av_frame_unref(frame);
175 return ret;
176 }
177
178 static int get_audio_buffer(AVFrame *frame, int align)
179 {
180 int planar = av_sample_fmt_is_planar(frame->format);
181 int channels, planes;
182 int ret;
183
184 #if FF_API_OLD_CHANNEL_LAYOUT
185 FF_DISABLE_DEPRECATION_WARNINGS
186 if (!frame->ch_layout.nb_channels) {
187 if (frame->channel_layout) {
188 av_channel_layout_from_mask(&frame->ch_layout, frame->channel_layout);
189 } else {
190 frame->ch_layout.nb_channels = frame->channels;
191 frame->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
192 }
193 }
194 frame->channels = frame->ch_layout.nb_channels;
195 frame->channel_layout = frame->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
196 frame->ch_layout.u.mask : 0;
197 FF_ENABLE_DEPRECATION_WARNINGS
198 #endif
199 channels = frame->ch_layout.nb_channels;
200 planes = planar ? channels : 1;
201 if (!frame->linesize[0]) {
202 ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
203 frame->nb_samples, frame->format,
204 align);
205 if (ret < 0)
206 return ret;
207 }
208
209 if (planes > AV_NUM_DATA_POINTERS) {
210 frame->extended_data = av_calloc(planes,
211 sizeof(*frame->extended_data));
212 frame->extended_buf = av_calloc(planes - AV_NUM_DATA_POINTERS,
213 sizeof(*frame->extended_buf));
214 if (!frame->extended_data || !frame->extended_buf) {
215 av_freep(&frame->extended_data);
216 av_freep(&frame->extended_buf);
217 return AVERROR(ENOMEM);
218 }
219 frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
220 } else
221 frame->extended_data = frame->data;
222
223 for (int i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
224 frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
225 if (!frame->buf[i]) {
226 av_frame_unref(frame);
227 return AVERROR(ENOMEM);
228 }
229 frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
230 }
231 for (int i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
232 frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
233 if (!frame->extended_buf[i]) {
234 av_frame_unref(frame);
235 return AVERROR(ENOMEM);
236 }
237 frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
238 }
239 return 0;
240
241 }
242
243 int av_frame_get_buffer(AVFrame *frame, int align)
244 {
245 if (frame->format < 0)
246 return AVERROR(EINVAL);
247
248 FF_DISABLE_DEPRECATION_WARNINGS
249 if (frame->width > 0 && frame->height > 0)
250 return get_video_buffer(frame, align);
251 else if (frame->nb_samples > 0 &&
252 (av_channel_layout_check(&frame->ch_layout)
253 #if FF_API_OLD_CHANNEL_LAYOUT
254 || frame->channel_layout || frame->channels > 0
255 #endif
256 ))
257 return get_audio_buffer(frame, align);
258 FF_ENABLE_DEPRECATION_WARNINGS
259
260 return AVERROR(EINVAL);
261 }
262
263 static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
264 {
265 int ret;
266
267 #if FF_API_FRAME_KEY
268 FF_DISABLE_DEPRECATION_WARNINGS
269 dst->key_frame = src->key_frame;
270 FF_ENABLE_DEPRECATION_WARNINGS
271 #endif
272 dst->pict_type = src->pict_type;
273 dst->sample_aspect_ratio = src->sample_aspect_ratio;
274 dst->crop_top = src->crop_top;
275 dst->crop_bottom = src->crop_bottom;
276 dst->crop_left = src->crop_left;
277 dst->crop_right = src->crop_right;
278 dst->pts = src->pts;
279 dst->duration = src->duration;
280 dst->repeat_pict = src->repeat_pict;
281 #if FF_API_INTERLACED_FRAME
282 FF_DISABLE_DEPRECATION_WARNINGS
283 dst->interlaced_frame = src->interlaced_frame;
284 dst->top_field_first = src->top_field_first;
285 FF_ENABLE_DEPRECATION_WARNINGS
286 #endif
287 #if FF_API_PALETTE_HAS_CHANGED
288 FF_DISABLE_DEPRECATION_WARNINGS
289 dst->palette_has_changed = src->palette_has_changed;
290 FF_ENABLE_DEPRECATION_WARNINGS
291 #endif
292 dst->sample_rate = src->sample_rate;
293 dst->opaque = src->opaque;
294 dst->pkt_dts = src->pkt_dts;
295 #if FF_API_FRAME_PKT
296 FF_DISABLE_DEPRECATION_WARNINGS
297 dst->pkt_pos = src->pkt_pos;
298 dst->pkt_size = src->pkt_size;
299 FF_ENABLE_DEPRECATION_WARNINGS
300 #endif
301 #if FF_API_PKT_DURATION
302 FF_DISABLE_DEPRECATION_WARNINGS
303 dst->pkt_duration = src->pkt_duration;
304 FF_ENABLE_DEPRECATION_WARNINGS
305 #endif
306 dst->time_base = src->time_base;
307 #if FF_API_REORDERED_OPAQUE
308 FF_DISABLE_DEPRECATION_WARNINGS
309 dst->reordered_opaque = src->reordered_opaque;
310 FF_ENABLE_DEPRECATION_WARNINGS
311 #endif
312 dst->quality = src->quality;
313 dst->best_effort_timestamp = src->best_effort_timestamp;
314 #if FF_API_FRAME_PICTURE_NUMBER
315 FF_DISABLE_DEPRECATION_WARNINGS
316 dst->coded_picture_number = src->coded_picture_number;
317 dst->display_picture_number = src->display_picture_number;
318 FF_ENABLE_DEPRECATION_WARNINGS
319 #endif
320 dst->flags = src->flags;
321 dst->decode_error_flags = src->decode_error_flags;
322 dst->color_primaries = src->color_primaries;
323 dst->color_trc = src->color_trc;
324 dst->colorspace = src->colorspace;
325 dst->color_range = src->color_range;
326 dst->chroma_location = src->chroma_location;
327
328 av_dict_copy(&dst->metadata, src->metadata, 0);
329
330 for (int i = 0; i < src->nb_side_data; i++) {
331 const AVFrameSideData *sd_src = src->side_data[i];
332 AVFrameSideData *sd_dst;
333 if ( sd_src->type == AV_FRAME_DATA_PANSCAN
334 && (src->width != dst->width || src->height != dst->height))
335 continue;
336 if (force_copy) {
337 sd_dst = av_frame_new_side_data(dst, sd_src->type,
338 sd_src->size);
339 if (!sd_dst) {
340 wipe_side_data(dst);
341 return AVERROR(ENOMEM);
342 }
343 memcpy(sd_dst->data, sd_src->data, sd_src->size);
344 } else {
345 AVBufferRef *ref = av_buffer_ref(sd_src->buf);
346 sd_dst = av_frame_new_side_data_from_buf(dst, sd_src->type, ref);
347 if (!sd_dst) {
348 av_buffer_unref(&ref);
349 wipe_side_data(dst);
350 return AVERROR(ENOMEM);
351 }
352 }
353 av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
354 }
355
356 ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
357 ret |= av_buffer_replace(&dst->private_ref, src->private_ref);
358 return ret;
359 }
360
361 int av_frame_ref(AVFrame *dst, const AVFrame *src)
362 {
363 int ret = 0;
364
365 av_assert1(dst->width == 0 && dst->height == 0);
366 #if FF_API_OLD_CHANNEL_LAYOUT
367 FF_DISABLE_DEPRECATION_WARNINGS
368 av_assert1(dst->channels == 0);
369 FF_ENABLE_DEPRECATION_WARNINGS
370 #endif
371 av_assert1(dst->ch_layout.nb_channels == 0 &&
372 dst->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
373
374 dst->format = src->format;
375 dst->width = src->width;
376 dst->height = src->height;
377 dst->nb_samples = src->nb_samples;
378 #if FF_API_OLD_CHANNEL_LAYOUT
379 FF_DISABLE_DEPRECATION_WARNINGS
380 dst->channels = src->channels;
381 dst->channel_layout = src->channel_layout;
382 if (!av_channel_layout_check(&src->ch_layout)) {
383 if (src->channel_layout)
384 av_channel_layout_from_mask(&dst->ch_layout, src->channel_layout);
385 else {
386 dst->ch_layout.nb_channels = src->channels;
387 dst->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
388 }
389 }
390 FF_ENABLE_DEPRECATION_WARNINGS
391 #endif
392
393 ret = frame_copy_props(dst, src, 0);
394 if (ret < 0)
395 goto fail;
396
397 // this check is needed only until FF_API_OLD_CHANNEL_LAYOUT is out
398 if (av_channel_layout_check(&src->ch_layout)) {
399 ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
400 if (ret < 0)
401 goto fail;
402 }
403
404 /* duplicate the frame data if it's not refcounted */
405 if (!src->buf[0]) {
406 ret = av_frame_get_buffer(dst, 0);
407 if (ret < 0)
408 goto fail;
409
410 ret = av_frame_copy(dst, src);
411 if (ret < 0)
412 goto fail;
413
414 return 0;
415 }
416
417 /* ref the buffers */
418 for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
419 if (!src->buf[i])
420 continue;
421 dst->buf[i] = av_buffer_ref(src->buf[i]);
422 if (!dst->buf[i]) {
423 ret = AVERROR(ENOMEM);
424 goto fail;
425 }
426 }
427
428 if (src->extended_buf) {
429 dst->extended_buf = av_calloc(src->nb_extended_buf,
430 sizeof(*dst->extended_buf));
431 if (!dst->extended_buf) {
432 ret = AVERROR(ENOMEM);
433 goto fail;
434 }
435 dst->nb_extended_buf = src->nb_extended_buf;
436
437 for (int i = 0; i < src->nb_extended_buf; i++) {
438 dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
439 if (!dst->extended_buf[i]) {
440 ret = AVERROR(ENOMEM);
441 goto fail;
442 }
443 }
444 }
445
446 if (src->hw_frames_ctx) {
447 dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
448 if (!dst->hw_frames_ctx) {
449 ret = AVERROR(ENOMEM);
450 goto fail;
451 }
452 }
453
454 /* duplicate extended data */
455 if (src->extended_data != src->data) {
456 int ch = dst->ch_layout.nb_channels;
457
458 if (!ch) {
459 ret = AVERROR(EINVAL);
460 goto fail;
461 }
462
463 dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
464 if (!dst->extended_data) {
465 ret = AVERROR(ENOMEM);
466 goto fail;
467 }
468 memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
469 } else
470 dst->extended_data = dst->data;
471
472 memcpy(dst->data, src->data, sizeof(src->data));
473 memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
474
475 return 0;
476
477 fail:
478 av_frame_unref(dst);
479 return ret;
480 }
481
482 int av_frame_replace(AVFrame *dst, const AVFrame *src)
483 {
484 int ret = 0;
485
486 if (dst == src)
487 return AVERROR(EINVAL);
488
489 if (!src->buf[0]) {
490 av_frame_unref(dst);
491
492 /* duplicate the frame data if it's not refcounted */
493 if ( src->data[0] || src->data[1]
494 || src->data[2] || src->data[3])
495 return av_frame_ref(dst, src);
496
497 ret = frame_copy_props(dst, src, 0);
498 if (ret < 0)
499 goto fail;
500 }
501
502 dst->format = src->format;
503 dst->width = src->width;
504 dst->height = src->height;
505 dst->nb_samples = src->nb_samples;
506 #if FF_API_OLD_CHANNEL_LAYOUT
507 FF_DISABLE_DEPRECATION_WARNINGS
508 dst->channels = src->channels;
509 dst->channel_layout = src->channel_layout;
510 if (!av_channel_layout_check(&src->ch_layout)) {
511 av_channel_layout_uninit(&dst->ch_layout);
512 if (src->channel_layout)
513 av_channel_layout_from_mask(&dst->ch_layout, src->channel_layout);
514 else {
515 dst->ch_layout.nb_channels = src->channels;
516 dst->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
517 }
518 } else {
519 #endif
520 ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
521 if (ret < 0)
522 goto fail;
523 #if FF_API_OLD_CHANNEL_LAYOUT
524 }
525 FF_ENABLE_DEPRECATION_WARNINGS
526 #endif
527
528 wipe_side_data(dst);
529 av_dict_free(&dst->metadata);
530 ret = frame_copy_props(dst, src, 0);
531 if (ret < 0)
532 goto fail;
533
534 /* replace the buffers */
535 for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
536 ret = av_buffer_replace(&dst->buf[i], src->buf[i]);
537 if (ret < 0)
538 goto fail;
539 }
540
541 if (src->extended_buf) {
542 if (dst->nb_extended_buf != src->nb_extended_buf) {
543 int nb_extended_buf = FFMIN(dst->nb_extended_buf, src->nb_extended_buf);
544 void *tmp;
545
546 for (int i = nb_extended_buf; i < dst->nb_extended_buf; i++)
547 av_buffer_unref(&dst->extended_buf[i]);
548
549 tmp = av_realloc_array(dst->extended_buf, sizeof(*dst->extended_buf),
550 src->nb_extended_buf);
551 if (!tmp) {
552 ret = AVERROR(ENOMEM);
553 goto fail;
554 }
555 dst->extended_buf = tmp;
556 dst->nb_extended_buf = src->nb_extended_buf;
557
558 memset(&dst->extended_buf[nb_extended_buf], 0,
559 (src->nb_extended_buf - nb_extended_buf) * sizeof(*dst->extended_buf));
560 }
561
562 for (int i = 0; i < src->nb_extended_buf; i++) {
563 ret = av_buffer_replace(&dst->extended_buf[i], src->extended_buf[i]);
564 if (ret < 0)
565 goto fail;
566 }
567 } else if (dst->extended_buf) {
568 for (int i = 0; i < dst->nb_extended_buf; i++)
569 av_buffer_unref(&dst->extended_buf[i]);
570 av_freep(&dst->extended_buf);
571 }
572
573 ret = av_buffer_replace(&dst->hw_frames_ctx, src->hw_frames_ctx);
574 if (ret < 0)
575 goto fail;
576
577 if (dst->extended_data != dst->data)
578 av_freep(&dst->extended_data);
579
580 if (src->extended_data != src->data) {
581 int ch = dst->ch_layout.nb_channels;
582
583 if (!ch) {
584 ret = AVERROR(EINVAL);
585 goto fail;
586 }
587
588 if (ch > SIZE_MAX / sizeof(*dst->extended_data))
589 goto fail;
590
591 dst->extended_data = av_memdup(src->extended_data, sizeof(*dst->extended_data) * ch);
592 if (!dst->extended_data) {
593 ret = AVERROR(ENOMEM);
594 goto fail;
595 }
596 } else
597 dst->extended_data = dst->data;
598
599 memcpy(dst->data, src->data, sizeof(src->data));
600 memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
601
602 return 0;
603
604 fail:
605 av_frame_unref(dst);
606 return ret;
607 }
608
609 AVFrame *av_frame_clone(const AVFrame *src)
610 {
611 AVFrame *ret = av_frame_alloc();
612
613 if (!ret)
614 return NULL;
615
616 if (av_frame_ref(ret, src) < 0)
617 av_frame_free(&ret);
618
619 return ret;
620 }
621
622 void av_frame_unref(AVFrame *frame)
623 {
624 if (!frame)
625 return;
626
627 wipe_side_data(frame);
628
629 for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
630 av_buffer_unref(&frame->buf[i]);
631 for (int i = 0; i < frame->nb_extended_buf; i++)
632 av_buffer_unref(&frame->extended_buf[i]);
633 av_freep(&frame->extended_buf);
634 av_dict_free(&frame->metadata);
635
636 av_buffer_unref(&frame->hw_frames_ctx);
637
638 av_buffer_unref(&frame->opaque_ref);
639 av_buffer_unref(&frame->private_ref);
640
641 if (frame->extended_data != frame->data)
642 av_freep(&frame->extended_data);
643
644 av_channel_layout_uninit(&frame->ch_layout);
645
646 get_frame_defaults(frame);
647 }
648
649 void av_frame_move_ref(AVFrame *dst, AVFrame *src)
650 {
651 av_assert1(dst->width == 0 && dst->height == 0);
652 #if FF_API_OLD_CHANNEL_LAYOUT
653 FF_DISABLE_DEPRECATION_WARNINGS
654 av_assert1(dst->channels == 0);
655 FF_ENABLE_DEPRECATION_WARNINGS
656 #endif
657 av_assert1(dst->ch_layout.nb_channels == 0 &&
658 dst->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
659
660 *dst = *src;
661 if (src->extended_data == src->data)
662 dst->extended_data = dst->data;
663 get_frame_defaults(src);
664 }
665
666 int av_frame_is_writable(AVFrame *frame)
667 {
668 int ret = 1;
669
670 /* assume non-refcounted frames are not writable */
671 if (!frame->buf[0])
672 return 0;
673
674 for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
675 if (frame->buf[i])
676 ret &= !!av_buffer_is_writable(frame->buf[i]);
677 for (int i = 0; i < frame->nb_extended_buf; i++)
678 ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
679
680 return ret;
681 }
682
683 int av_frame_make_writable(AVFrame *frame)
684 {
685 AVFrame tmp;
686 int ret;
687
688 if (av_frame_is_writable(frame))
689 return 0;
690
691 memset(&tmp, 0, sizeof(tmp));
692 tmp.format = frame->format;
693 tmp.width = frame->width;
694 tmp.height = frame->height;
695 #if FF_API_OLD_CHANNEL_LAYOUT
696 FF_DISABLE_DEPRECATION_WARNINGS
697 tmp.channels = frame->channels;
698 tmp.channel_layout = frame->channel_layout;
699 FF_ENABLE_DEPRECATION_WARNINGS
700 #endif
701 tmp.nb_samples = frame->nb_samples;
702 ret = av_channel_layout_copy(&tmp.ch_layout, &frame->ch_layout);
703 if (ret < 0) {
704 av_frame_unref(&tmp);
705 return ret;
706 }
707
708 if (frame->hw_frames_ctx)
709 ret = av_hwframe_get_buffer(frame->hw_frames_ctx, &tmp, 0);
710 else
711 ret = av_frame_get_buffer(&tmp, 0);
712 if (ret < 0)
713 return ret;
714
715 ret = av_frame_copy(&tmp, frame);
716 if (ret < 0) {
717 av_frame_unref(&tmp);
718 return ret;
719 }
720
721 ret = av_frame_copy_props(&tmp, frame);
722 if (ret < 0) {
723 av_frame_unref(&tmp);
724 return ret;
725 }
726
727 av_frame_unref(frame);
728
729 *frame = tmp;
730 if (tmp.data == tmp.extended_data)
731 frame->extended_data = frame->data;
732
733 return 0;
734 }
735
736 int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
737 {
738 return frame_copy_props(dst, src, 1);
739 }
740
741 AVBufferRef *av_frame_get_plane_buffer(const AVFrame *frame, int plane)
742 {
743 uint8_t *data;
744 int planes;
745
746 if (frame->nb_samples) {
747 int channels = frame->ch_layout.nb_channels;
748
749 #if FF_API_OLD_CHANNEL_LAYOUT
750 FF_DISABLE_DEPRECATION_WARNINGS
751 if (!channels) {
752 channels = frame->channels;
753 CHECK_CHANNELS_CONSISTENCY(frame);
754 }
755 FF_ENABLE_DEPRECATION_WARNINGS
756 #endif
757 if (!channels)
758 return NULL;
759 planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
760 } else
761 planes = 4;
762
763 if (plane < 0 || plane >= planes || !frame->extended_data[plane])
764 return NULL;
765 data = frame->extended_data[plane];
766
767 for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
768 AVBufferRef *buf = frame->buf[i];
769 if (data >= buf->data && data < buf->data + buf->size)
770 return buf;
771 }
772 for (int i = 0; i < frame->nb_extended_buf; i++) {
773 AVBufferRef *buf = frame->extended_buf[i];
774 if (data >= buf->data && data < buf->data + buf->size)
775 return buf;
776 }
777 return NULL;
778 }
779
780 AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
781 enum AVFrameSideDataType type,
782 AVBufferRef *buf)
783 {
784 AVFrameSideData *ret, **tmp;
785
786 if (!buf)
787 return NULL;
788
789 if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
790 return NULL;
791
792 tmp = av_realloc(frame->side_data,
793 (frame->nb_side_data + 1) * sizeof(*frame->side_data));
794 if (!tmp)
795 return NULL;
796 frame->side_data = tmp;
797
798 ret = av_mallocz(sizeof(*ret));
799 if (!ret)
800 return NULL;
801
802 ret->buf = buf;
803 ret->data = ret->buf->data;
804 ret->size = buf->size;
805 ret->type = type;
806
807 frame->side_data[frame->nb_side_data++] = ret;
808
809 return ret;
810 }
811
812 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
813 enum AVFrameSideDataType type,
814 size_t size)
815 {
816 AVFrameSideData *ret;
817 AVBufferRef *buf = av_buffer_alloc(size);
818 ret = av_frame_new_side_data_from_buf(frame, type, buf);
819 if (!ret)
820 av_buffer_unref(&buf);
821 return ret;
822 }
823
824 AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
825 enum AVFrameSideDataType type)
826 {
827 for (int i = 0; i < frame->nb_side_data; i++) {
828 if (frame->side_data[i]->type == type)
829 return frame->side_data[i];
830 }
831 return NULL;
832 }
833
834 static int frame_copy_video(AVFrame *dst, const AVFrame *src)
835 {
836 int planes;
837
838 if (dst->width < src->width ||
839 dst->height < src->height)
840 return AVERROR(EINVAL);
841
842 if (src->hw_frames_ctx || dst->hw_frames_ctx)
843 return av_hwframe_transfer_data(dst, src, 0);
844
845 planes = av_pix_fmt_count_planes(dst->format);
846 for (int i = 0; i < planes; i++)
847 if (!dst->data[i] || !src->data[i])
848 return AVERROR(EINVAL);
849
850 av_image_copy2(dst->data, dst->linesize,
851 src->data, src->linesize,
852 dst->format, src->width, src->height);
853
854 return 0;
855 }
856
857 static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
858 {
859 int planar = av_sample_fmt_is_planar(dst->format);
860 int channels = dst->ch_layout.nb_channels;
861 int planes = planar ? channels : 1;
862
863 #if FF_API_OLD_CHANNEL_LAYOUT
864 FF_DISABLE_DEPRECATION_WARNINGS
865 if (!channels || !src->ch_layout.nb_channels) {
866 if (dst->channels != src->channels ||
867 dst->channel_layout != src->channel_layout)
868 return AVERROR(EINVAL);
869 CHECK_CHANNELS_CONSISTENCY(src);
870 }
871 if (!channels) {
872 channels = dst->channels;
873 planes = planar ? channels : 1;
874 }
875 FF_ENABLE_DEPRECATION_WARNINGS
876 #endif
877
878 if (dst->nb_samples != src->nb_samples ||
879 #if FF_API_OLD_CHANNEL_LAYOUT
880 (av_channel_layout_check(&dst->ch_layout) &&
881 av_channel_layout_check(&src->ch_layout) &&
882 #endif
883 av_channel_layout_compare(&dst->ch_layout, &src->ch_layout))
884 #if FF_API_OLD_CHANNEL_LAYOUT
885 )
886 #endif
887 return AVERROR(EINVAL);
888
889 for (int i = 0; i < planes; i++)
890 if (!dst->extended_data[i] || !src->extended_data[i])
891 return AVERROR(EINVAL);
892
893 av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
894 dst->nb_samples, channels, dst->format);
895
896 return 0;
897 }
898
899 int av_frame_copy(AVFrame *dst, const AVFrame *src)
900 {
901 if (dst->format != src->format || dst->format < 0)
902 return AVERROR(EINVAL);
903
904 FF_DISABLE_DEPRECATION_WARNINGS
905 if (dst->width > 0 && dst->height > 0)
906 return frame_copy_video(dst, src);
907 else if (dst->nb_samples > 0 &&
908 (av_channel_layout_check(&dst->ch_layout)
909 #if FF_API_OLD_CHANNEL_LAYOUT
910 || dst->channels > 0
911 #endif
912 ))
913 return frame_copy_audio(dst, src);
914 FF_ENABLE_DEPRECATION_WARNINGS
915
916 return AVERROR(EINVAL);
917 }
918
919 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
920 {
921 for (int i = frame->nb_side_data - 1; i >= 0; i--) {
922 AVFrameSideData *sd = frame->side_data[i];
923 if (sd->type == type) {
924 free_side_data(&frame->side_data[i]);
925 frame->side_data[i] = frame->side_data[frame->nb_side_data - 1];
926 frame->nb_side_data--;
927 }
928 }
929 }
930
931 const char *av_frame_side_data_name(enum AVFrameSideDataType type)
932 {
933 switch(type) {
934 case AV_FRAME_DATA_PANSCAN: return "AVPanScan";
935 case AV_FRAME_DATA_A53_CC: return "ATSC A53 Part 4 Closed Captions";
936 case AV_FRAME_DATA_STEREO3D: return "Stereo 3D";
937 case AV_FRAME_DATA_MATRIXENCODING: return "AVMatrixEncoding";
938 case AV_FRAME_DATA_DOWNMIX_INFO: return "Metadata relevant to a downmix procedure";
939 case AV_FRAME_DATA_REPLAYGAIN: return "AVReplayGain";
940 case AV_FRAME_DATA_DISPLAYMATRIX: return "3x3 displaymatrix";
941 case AV_FRAME_DATA_AFD: return "Active format description";
942 case AV_FRAME_DATA_MOTION_VECTORS: return "Motion vectors";
943 case AV_FRAME_DATA_SKIP_SAMPLES: return "Skip samples";
944 case AV_FRAME_DATA_AUDIO_SERVICE_TYPE: return "Audio service type";
945 case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
946 case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
947 case AV_FRAME_DATA_GOP_TIMECODE: return "GOP timecode";
948 case AV_FRAME_DATA_S12M_TIMECODE: return "SMPTE 12-1 timecode";
949 case AV_FRAME_DATA_SPHERICAL: return "Spherical Mapping";
950 case AV_FRAME_DATA_ICC_PROFILE: return "ICC profile";
951 case AV_FRAME_DATA_DYNAMIC_HDR_PLUS: return "HDR Dynamic Metadata SMPTE2094-40 (HDR10+)";
952 case AV_FRAME_DATA_DYNAMIC_HDR_VIVID: return "HDR Dynamic Metadata CUVA 005.1 2021 (Vivid)";
953 case AV_FRAME_DATA_REGIONS_OF_INTEREST: return "Regions Of Interest";
954 case AV_FRAME_DATA_VIDEO_ENC_PARAMS: return "Video encoding parameters";
955 case AV_FRAME_DATA_SEI_UNREGISTERED: return "H.26[45] User Data Unregistered SEI message";
956 case AV_FRAME_DATA_FILM_GRAIN_PARAMS: return "Film grain parameters";
957 case AV_FRAME_DATA_DETECTION_BBOXES: return "Bounding boxes for object detection and classification";
958 case AV_FRAME_DATA_DOVI_RPU_BUFFER: return "Dolby Vision RPU Data";
959 case AV_FRAME_DATA_DOVI_METADATA: return "Dolby Vision Metadata";
960 case AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT: return "Ambient viewing environment";
961 }
962 return NULL;
963 }
964
965 static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
966 const AVPixFmtDescriptor *desc)
967 {
968 for (int i = 0; frame->data[i]; i++) {
969 const AVComponentDescriptor *comp = NULL;
970 int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
971 int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
972
973 if (desc->flags & AV_PIX_FMT_FLAG_PAL && i == 1) {
974 offsets[i] = 0;
975 break;
976 }
977
978 /* find any component descriptor for this plane */
979 for (int j = 0; j < desc->nb_components; j++) {
980 if (desc->comp[j].plane == i) {
981 comp = &desc->comp[j];
982 break;
983 }
984 }
985 if (!comp)
986 return AVERROR_BUG;
987
988 offsets[i] = (frame->crop_top >> shift_y) * frame->linesize[i] +
989 (frame->crop_left >> shift_x) * comp->step;
990 }
991
992 return 0;
993 }
994
995 int av_frame_apply_cropping(AVFrame *frame, int flags)
996 {
997 const AVPixFmtDescriptor *desc;
998 size_t offsets[4];
999
1000 if (!(frame->width > 0 && frame->height > 0))
1001 return AVERROR(EINVAL);
1002
1003 if (frame->crop_left >= INT_MAX - frame->crop_right ||
1004 frame->crop_top >= INT_MAX - frame->crop_bottom ||
1005 (frame->crop_left + frame->crop_right) >= frame->width ||
1006 (frame->crop_top + frame->crop_bottom) >= frame->height)
1007 return AVERROR(ERANGE);
1008
1009 desc = av_pix_fmt_desc_get(frame->format);
1010 if (!desc)
1011 return AVERROR_BUG;
1012
1013 /* Apply just the right/bottom cropping for hwaccel formats. Bitstream
1014 * formats cannot be easily handled here either (and corresponding decoders
1015 * should not export any cropping anyway), so do the same for those as well.
1016 * */
1017 if (desc->flags & (AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_HWACCEL)) {
1018 frame->width -= frame->crop_right;
1019 frame->height -= frame->crop_bottom;
1020 frame->crop_right = 0;
1021 frame->crop_bottom = 0;
1022 return 0;
1023 }
1024
1025 /* calculate the offsets for each plane */
1026 calc_cropping_offsets(offsets, frame, desc);
1027
1028 /* adjust the offsets to avoid breaking alignment */
1029 if (!(flags & AV_FRAME_CROP_UNALIGNED)) {
1030 int log2_crop_align = frame->crop_left ? ff_ctz(frame->crop_left) : INT_MAX;
1031 int min_log2_align = INT_MAX;
1032
1033 for (int i = 0; frame->data[i]; i++) {
1034 int log2_align = offsets[i] ? ff_ctz(offsets[i]) : INT_MAX;
1035 min_log2_align = FFMIN(log2_align, min_log2_align);
1036 }
1037
1038 /* we assume, and it should always be true, that the data alignment is
1039 * related to the cropping alignment by a constant power-of-2 factor */
1040 if (log2_crop_align < min_log2_align)
1041 return AVERROR_BUG;
1042
1043 if (min_log2_align < 5) {
1044 frame->crop_left &= ~((1 << (5 + log2_crop_align - min_log2_align)) - 1);
1045 calc_cropping_offsets(offsets, frame, desc);
1046 }
1047 }
1048
1049 for (int i = 0; frame->data[i]; i++)
1050 frame->data[i] += offsets[i];
1051
1052 frame->width -= (frame->crop_left + frame->crop_right);
1053 frame->height -= (frame->crop_top + frame->crop_bottom);
1054 frame->crop_left = 0;
1055 frame->crop_right = 0;
1056 frame->crop_top = 0;
1057 frame->crop_bottom = 0;
1058
1059 return 0;
1060 }