LCOV - code coverage report
Current view: top level - src/libavutil - frame.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 308 444 69.4 %
Date: 2017-01-21 09:32:20 Functions: 43 50 86.0 %

          Line data    Source code
       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 "dict.h"
      24             : #include "frame.h"
      25             : #include "imgutils.h"
      26             : #include "mem.h"
      27             : #include "samplefmt.h"
      28             : 
      29      491939 : MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)
      30      676854 : MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)
      31     2995158 : MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)
      32        5746 : MAKE_ACCESSORS(AVFrame, frame, int64_t, channel_layout)
      33     3390565 : MAKE_ACCESSORS(AVFrame, frame, int,     channels)
      34           0 : MAKE_ACCESSORS(AVFrame, frame, int,     sample_rate)
      35        7095 : MAKE_ACCESSORS(AVFrame, frame, AVDictionary *, metadata)
      36        1993 : MAKE_ACCESSORS(AVFrame, frame, int,     decode_error_flags)
      37      487460 : MAKE_ACCESSORS(AVFrame, frame, int,     pkt_size)
      38     1024833 : MAKE_ACCESSORS(AVFrame, frame, enum AVColorSpace, colorspace)
      39     1015767 : MAKE_ACCESSORS(AVFrame, frame, enum AVColorRange, color_range)
      40             : 
      41             : #define CHECK_CHANNELS_CONSISTENCY(frame) \
      42             :     av_assert2(!(frame)->channel_layout || \
      43             :                (frame)->channels == \
      44             :                av_get_channel_layout_nb_channels((frame)->channel_layout))
      45             : 
      46      468298 : AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame) {return &frame->metadata;};
      47             : 
      48             : #if FF_API_FRAME_QP
      49       11307 : int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
      50             : {
      51       11307 :     av_buffer_unref(&f->qp_table_buf);
      52             : 
      53       11307 :     f->qp_table_buf = buf;
      54             : 
      55             : FF_DISABLE_DEPRECATION_WARNINGS
      56       11307 :     f->qscale_table = buf->data;
      57       11307 :     f->qstride      = stride;
      58       11307 :     f->qscale_type  = qp_type;
      59             : FF_ENABLE_DEPRECATION_WARNINGS
      60             : 
      61       11307 :     return 0;
      62             : }
      63             : 
      64          56 : int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type)
      65             : {
      66             : FF_DISABLE_DEPRECATION_WARNINGS
      67          56 :     *stride = f->qstride;
      68          56 :     *type   = f->qscale_type;
      69             : FF_ENABLE_DEPRECATION_WARNINGS
      70             : 
      71          56 :     if (!f->qp_table_buf)
      72          36 :         return NULL;
      73             : 
      74          20 :     return f->qp_table_buf->data;
      75             : }
      76             : #endif
      77             : 
      78          86 : const char *av_get_colorspace_name(enum AVColorSpace val)
      79             : {
      80             :     static const char * const name[] = {
      81             :         [AVCOL_SPC_RGB]       = "GBR",
      82             :         [AVCOL_SPC_BT709]     = "bt709",
      83             :         [AVCOL_SPC_FCC]       = "fcc",
      84             :         [AVCOL_SPC_BT470BG]   = "bt470bg",
      85             :         [AVCOL_SPC_SMPTE170M] = "smpte170m",
      86             :         [AVCOL_SPC_SMPTE240M] = "smpte240m",
      87             :         [AVCOL_SPC_YCOCG]     = "YCgCo",
      88             :     };
      89          86 :     if ((unsigned)val >= FF_ARRAY_ELEMS(name))
      90           0 :         return NULL;
      91          86 :     return name[val];
      92             : }
      93             : 
      94     5792489 : static void get_frame_defaults(AVFrame *frame)
      95             : {
      96     5792489 :     if (frame->extended_data != frame->data)
      97     2142772 :         av_freep(&frame->extended_data);
      98             : 
      99     5792489 :     memset(frame, 0, sizeof(*frame));
     100             : 
     101     5792489 :     frame->pts                   =
     102     5792489 :     frame->pkt_dts               = AV_NOPTS_VALUE;
     103             : #if FF_API_PKT_PTS
     104             : FF_DISABLE_DEPRECATION_WARNINGS
     105     5792489 :     frame->pkt_pts               = AV_NOPTS_VALUE;
     106             : FF_ENABLE_DEPRECATION_WARNINGS
     107             : #endif
     108     5792489 :     frame->best_effort_timestamp = AV_NOPTS_VALUE;
     109     5792489 :     frame->pkt_duration        = 0;
     110     5792489 :     frame->pkt_pos             = -1;
     111     5792489 :     frame->pkt_size            = -1;
     112     5792489 :     frame->key_frame           = 1;
     113     5792489 :     frame->sample_aspect_ratio = (AVRational){ 0, 1 };
     114     5792489 :     frame->format              = -1; /* unknown */
     115     5792489 :     frame->extended_data       = frame->data;
     116     5792489 :     frame->color_primaries     = AVCOL_PRI_UNSPECIFIED;
     117     5792489 :     frame->color_trc           = AVCOL_TRC_UNSPECIFIED;
     118     5792489 :     frame->colorspace          = AVCOL_SPC_UNSPECIFIED;
     119     5792489 :     frame->color_range         = AVCOL_RANGE_UNSPECIFIED;
     120     5792489 :     frame->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
     121     5792489 :     frame->flags               = 0;
     122     5792489 : }
     123             : 
     124       97884 : static void free_side_data(AVFrameSideData **ptr_sd)
     125             : {
     126       97884 :     AVFrameSideData *sd = *ptr_sd;
     127             : 
     128       97884 :     av_buffer_unref(&sd->buf);
     129       97884 :     av_dict_free(&sd->metadata);
     130       97884 :     av_freep(ptr_sd);
     131       97884 : }
     132             : 
     133     3649719 : static void wipe_side_data(AVFrame *frame)
     134             : {
     135             :     int i;
     136             : 
     137     3747603 :     for (i = 0; i < frame->nb_side_data; i++) {
     138       97884 :         free_side_data(&frame->side_data[i]);
     139             :     }
     140     3649719 :     frame->nb_side_data = 0;
     141             : 
     142     3649719 :     av_freep(&frame->side_data);
     143     3649719 : }
     144             : 
     145      980487 : AVFrame *av_frame_alloc(void)
     146             : {
     147      980487 :     AVFrame *frame = av_mallocz(sizeof(*frame));
     148             : 
     149      980487 :     if (!frame)
     150           0 :         return NULL;
     151             : 
     152      980487 :     frame->extended_data = NULL;
     153      980487 :     get_frame_defaults(frame);
     154             : 
     155      980487 :     return frame;
     156             : }
     157             : 
     158     1313854 : void av_frame_free(AVFrame **frame)
     159             : {
     160     1313854 :     if (!frame || !*frame)
     161      333367 :         return;
     162             : 
     163      980487 :     av_frame_unref(*frame);
     164      980487 :     av_freep(frame);
     165             : }
     166             : 
     167        1358 : static int get_video_buffer(AVFrame *frame, int align)
     168             : {
     169        1358 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
     170             :     int ret, i;
     171             : 
     172        1358 :     if (!desc)
     173           0 :         return AVERROR(EINVAL);
     174             : 
     175        1358 :     if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
     176           0 :         return ret;
     177             : 
     178        1358 :     if (!frame->linesize[0]) {
     179        3573 :         for(i=1; i<=align; i+=i) {
     180        3573 :             ret = av_image_fill_linesizes(frame->linesize, frame->format,
     181        3573 :                                           FFALIGN(frame->width, i));
     182        3573 :             if (ret < 0)
     183           0 :                 return ret;
     184        3573 :             if (!(frame->linesize[0] & (align-1)))
     185        1358 :                 break;
     186             :         }
     187             : 
     188        4536 :         for (i = 0; i < 4 && frame->linesize[i]; i++)
     189        3178 :             frame->linesize[i] = FFALIGN(frame->linesize[i], align);
     190             :     }
     191             : 
     192        4536 :     for (i = 0; i < 4 && frame->linesize[i]; i++) {
     193        3178 :         int h = FFALIGN(frame->height, 32);
     194        3178 :         if (i == 1 || i == 2)
     195        1720 :             h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
     196             : 
     197        3178 :         frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 16 + 16/*STRIDE_ALIGN*/ - 1);
     198        3178 :         if (!frame->buf[i])
     199           0 :             goto fail;
     200             : 
     201        3178 :         frame->data[i] = frame->buf[i]->data;
     202             :     }
     203        1358 :     if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
     204           0 :         av_buffer_unref(&frame->buf[1]);
     205           0 :         frame->buf[1] = av_buffer_alloc(AVPALETTE_SIZE);
     206           0 :         if (!frame->buf[1])
     207           0 :             goto fail;
     208           0 :         frame->data[1] = frame->buf[1]->data;
     209             :     }
     210             : 
     211        1358 :     frame->extended_data = frame->data;
     212             : 
     213        1358 :     return 0;
     214             : fail:
     215           0 :     av_frame_unref(frame);
     216           0 :     return AVERROR(ENOMEM);
     217             : }
     218             : 
     219          55 : static int get_audio_buffer(AVFrame *frame, int align)
     220             : {
     221             :     int channels;
     222          55 :     int planar   = av_sample_fmt_is_planar(frame->format);
     223             :     int planes;
     224             :     int ret, i;
     225             : 
     226          55 :     if (!frame->channels)
     227          16 :         frame->channels = av_get_channel_layout_nb_channels(frame->channel_layout);
     228             : 
     229          55 :     channels = frame->channels;
     230          55 :     planes = planar ? channels : 1;
     231             : 
     232             :     CHECK_CHANNELS_CONSISTENCY(frame);
     233          55 :     if (!frame->linesize[0]) {
     234          55 :         ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
     235          55 :                                          frame->nb_samples, frame->format,
     236             :                                          align);
     237          55 :         if (ret < 0)
     238           0 :             return ret;
     239             :     }
     240             : 
     241          55 :     if (planes > AV_NUM_DATA_POINTERS) {
     242           0 :         frame->extended_data = av_mallocz_array(planes,
     243             :                                           sizeof(*frame->extended_data));
     244           0 :         frame->extended_buf  = av_mallocz_array((planes - AV_NUM_DATA_POINTERS),
     245             :                                           sizeof(*frame->extended_buf));
     246           0 :         if (!frame->extended_data || !frame->extended_buf) {
     247           0 :             av_freep(&frame->extended_data);
     248           0 :             av_freep(&frame->extended_buf);
     249           0 :             return AVERROR(ENOMEM);
     250             :         }
     251           0 :         frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
     252             :     } else
     253          55 :         frame->extended_data = frame->data;
     254             : 
     255         120 :     for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
     256          65 :         frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
     257          65 :         if (!frame->buf[i]) {
     258           0 :             av_frame_unref(frame);
     259           0 :             return AVERROR(ENOMEM);
     260             :         }
     261          65 :         frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
     262             :     }
     263          55 :     for (i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
     264           0 :         frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
     265           0 :         if (!frame->extended_buf[i]) {
     266           0 :             av_frame_unref(frame);
     267           0 :             return AVERROR(ENOMEM);
     268             :         }
     269           0 :         frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
     270             :     }
     271          55 :     return 0;
     272             : 
     273             : }
     274             : 
     275        1413 : int av_frame_get_buffer(AVFrame *frame, int align)
     276             : {
     277        1413 :     if (frame->format < 0)
     278           0 :         return AVERROR(EINVAL);
     279             : 
     280        1413 :     if (frame->width > 0 && frame->height > 0)
     281        1358 :         return get_video_buffer(frame, align);
     282          55 :     else if (frame->nb_samples > 0 && (frame->channel_layout || frame->channels > 0))
     283          55 :         return get_audio_buffer(frame, align);
     284             : 
     285           0 :     return AVERROR(EINVAL);
     286             : }
     287             : 
     288      643992 : static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
     289             : {
     290             :     int i;
     291             : 
     292      643992 :     dst->key_frame              = src->key_frame;
     293      643992 :     dst->pict_type              = src->pict_type;
     294      643992 :     dst->sample_aspect_ratio    = src->sample_aspect_ratio;
     295      643992 :     dst->pts                    = src->pts;
     296      643992 :     dst->repeat_pict            = src->repeat_pict;
     297      643992 :     dst->interlaced_frame       = src->interlaced_frame;
     298      643992 :     dst->top_field_first        = src->top_field_first;
     299      643992 :     dst->palette_has_changed    = src->palette_has_changed;
     300      643992 :     dst->sample_rate            = src->sample_rate;
     301      643992 :     dst->opaque                 = src->opaque;
     302             : #if FF_API_PKT_PTS
     303             : FF_DISABLE_DEPRECATION_WARNINGS
     304      643992 :     dst->pkt_pts                = src->pkt_pts;
     305             : FF_ENABLE_DEPRECATION_WARNINGS
     306             : #endif
     307      643992 :     dst->pkt_dts                = src->pkt_dts;
     308      643992 :     dst->pkt_pos                = src->pkt_pos;
     309      643992 :     dst->pkt_size               = src->pkt_size;
     310      643992 :     dst->pkt_duration           = src->pkt_duration;
     311      643992 :     dst->reordered_opaque       = src->reordered_opaque;
     312      643992 :     dst->quality                = src->quality;
     313      643992 :     dst->best_effort_timestamp  = src->best_effort_timestamp;
     314      643992 :     dst->coded_picture_number   = src->coded_picture_number;
     315      643992 :     dst->display_picture_number = src->display_picture_number;
     316      643992 :     dst->flags                  = src->flags;
     317      643992 :     dst->decode_error_flags     = src->decode_error_flags;
     318      643992 :     dst->color_primaries        = src->color_primaries;
     319      643992 :     dst->color_trc              = src->color_trc;
     320      643992 :     dst->colorspace             = src->colorspace;
     321      643992 :     dst->color_range            = src->color_range;
     322      643992 :     dst->chroma_location        = src->chroma_location;
     323             : 
     324      643992 :     av_dict_copy(&dst->metadata, src->metadata, 0);
     325             : 
     326             : #if FF_API_ERROR_FRAME
     327             : FF_DISABLE_DEPRECATION_WARNINGS
     328      643992 :     memcpy(dst->error, src->error, sizeof(dst->error));
     329             : FF_ENABLE_DEPRECATION_WARNINGS
     330             : #endif
     331             : 
     332      715133 :     for (i = 0; i < src->nb_side_data; i++) {
     333       71141 :         const AVFrameSideData *sd_src = src->side_data[i];
     334             :         AVFrameSideData *sd_dst;
     335       71141 :         if (   sd_src->type == AV_FRAME_DATA_PANSCAN
     336       12056 :             && (src->width != dst->width || src->height != dst->height))
     337          75 :             continue;
     338       71066 :         if (force_copy) {
     339        7105 :             sd_dst = av_frame_new_side_data(dst, sd_src->type,
     340             :                                             sd_src->size);
     341        7105 :             if (!sd_dst) {
     342           0 :                 wipe_side_data(dst);
     343           0 :                 return AVERROR(ENOMEM);
     344             :             }
     345        7105 :             memcpy(sd_dst->data, sd_src->data, sd_src->size);
     346             :         } else {
     347       63961 :             sd_dst = av_frame_new_side_data(dst, sd_src->type, 0);
     348       63961 :             if (!sd_dst) {
     349           0 :                 wipe_side_data(dst);
     350           0 :                 return AVERROR(ENOMEM);
     351             :             }
     352       63961 :             if (sd_src->buf) {
     353       63961 :                 sd_dst->buf = av_buffer_ref(sd_src->buf);
     354       63961 :                 if (!sd_dst->buf) {
     355           0 :                     wipe_side_data(dst);
     356           0 :                     return AVERROR(ENOMEM);
     357             :                 }
     358       63961 :                 sd_dst->data = sd_dst->buf->data;
     359       63961 :                 sd_dst->size = sd_dst->buf->size;
     360             :             }
     361             :         }
     362       71066 :         av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
     363             :     }
     364             : 
     365             : #if FF_API_FRAME_QP
     366             : FF_DISABLE_DEPRECATION_WARNINGS
     367      643992 :     dst->qscale_table = NULL;
     368      643992 :     dst->qstride      = 0;
     369      643992 :     dst->qscale_type  = 0;
     370      643992 :     av_buffer_unref(&dst->qp_table_buf);
     371      643992 :     if (src->qp_table_buf) {
     372       14045 :         dst->qp_table_buf = av_buffer_ref(src->qp_table_buf);
     373       14045 :         if (dst->qp_table_buf) {
     374       14045 :             dst->qscale_table = dst->qp_table_buf->data;
     375       14045 :             dst->qstride      = src->qstride;
     376       14045 :             dst->qscale_type  = src->qscale_type;
     377             :         }
     378             :     }
     379             : FF_ENABLE_DEPRECATION_WARNINGS
     380             : #endif
     381             : 
     382      643992 :     return 0;
     383             : }
     384             : 
     385      300300 : int av_frame_ref(AVFrame *dst, const AVFrame *src)
     386             : {
     387      300300 :     int i, ret = 0;
     388             : 
     389             :     av_assert1(dst->width == 0 && dst->height == 0);
     390             :     av_assert1(dst->channels == 0);
     391             : 
     392      300300 :     dst->format         = src->format;
     393      300300 :     dst->width          = src->width;
     394      300300 :     dst->height         = src->height;
     395      300300 :     dst->channels       = src->channels;
     396      300300 :     dst->channel_layout = src->channel_layout;
     397      300300 :     dst->nb_samples     = src->nb_samples;
     398             : 
     399      300300 :     ret = frame_copy_props(dst, src, 0);
     400      300300 :     if (ret < 0)
     401           0 :         return ret;
     402             : 
     403             :     /* duplicate the frame data if it's not refcounted */
     404      300300 :     if (!src->buf[0]) {
     405          13 :         ret = av_frame_get_buffer(dst, 32);
     406          13 :         if (ret < 0)
     407           0 :             return ret;
     408             : 
     409          13 :         ret = av_frame_copy(dst, src);
     410          13 :         if (ret < 0)
     411           0 :             av_frame_unref(dst);
     412             : 
     413          13 :         return ret;
     414             :     }
     415             : 
     416             :     /* ref the buffers */
     417     2702583 :     for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
     418     2402296 :         if (!src->buf[i])
     419     1578155 :             continue;
     420      824141 :         dst->buf[i] = av_buffer_ref(src->buf[i]);
     421      824141 :         if (!dst->buf[i]) {
     422           0 :             ret = AVERROR(ENOMEM);
     423           0 :             goto fail;
     424             :         }
     425             :     }
     426             : 
     427      300287 :     if (src->extended_buf) {
     428           0 :         dst->extended_buf = av_mallocz_array(sizeof(*dst->extended_buf),
     429           0 :                                        src->nb_extended_buf);
     430           0 :         if (!dst->extended_buf) {
     431           0 :             ret = AVERROR(ENOMEM);
     432           0 :             goto fail;
     433             :         }
     434           0 :         dst->nb_extended_buf = src->nb_extended_buf;
     435             : 
     436           0 :         for (i = 0; i < src->nb_extended_buf; i++) {
     437           0 :             dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
     438           0 :             if (!dst->extended_buf[i]) {
     439           0 :                 ret = AVERROR(ENOMEM);
     440           0 :                 goto fail;
     441             :             }
     442             :         }
     443             :     }
     444             : 
     445      300287 :     if (src->hw_frames_ctx) {
     446           0 :         dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
     447           0 :         if (!dst->hw_frames_ctx) {
     448           0 :             ret = AVERROR(ENOMEM);
     449           0 :             goto fail;
     450             :         }
     451             :     }
     452             : 
     453             :     /* duplicate extended data */
     454      300287 :     if (src->extended_data != src->data) {
     455           0 :         int ch = src->channels;
     456             : 
     457           0 :         if (!ch) {
     458           0 :             ret = AVERROR(EINVAL);
     459           0 :             goto fail;
     460             :         }
     461             :         CHECK_CHANNELS_CONSISTENCY(src);
     462             : 
     463           0 :         dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
     464           0 :         if (!dst->extended_data) {
     465           0 :             ret = AVERROR(ENOMEM);
     466           0 :             goto fail;
     467             :         }
     468           0 :         memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
     469             :     } else
     470      300287 :         dst->extended_data = dst->data;
     471             : 
     472      300287 :     memcpy(dst->data,     src->data,     sizeof(src->data));
     473      300287 :     memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
     474             : 
     475      300287 :     return 0;
     476             : 
     477             : fail:
     478           0 :     av_frame_unref(dst);
     479           0 :     return ret;
     480             : }
     481             : 
     482        5723 : AVFrame *av_frame_clone(const AVFrame *src)
     483             : {
     484        5723 :     AVFrame *ret = av_frame_alloc();
     485             : 
     486        5723 :     if (!ret)
     487           0 :         return NULL;
     488             : 
     489        5723 :     if (av_frame_ref(ret, src) < 0)
     490           0 :         av_frame_free(&ret);
     491             : 
     492        5723 :     return ret;
     493             : }
     494             : 
     495     3649719 : void av_frame_unref(AVFrame *frame)
     496             : {
     497             :     int i;
     498             : 
     499     3649719 :     if (!frame)
     500           0 :         return;
     501             : 
     502     3649719 :     wipe_side_data(frame);
     503             : 
     504    32847471 :     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
     505    29197752 :         av_buffer_unref(&frame->buf[i]);
     506     3649719 :     for (i = 0; i < frame->nb_extended_buf; i++)
     507           0 :         av_buffer_unref(&frame->extended_buf[i]);
     508     3649719 :     av_freep(&frame->extended_buf);
     509     3649719 :     av_dict_free(&frame->metadata);
     510             : #if FF_API_FRAME_QP
     511     3649719 :     av_buffer_unref(&frame->qp_table_buf);
     512             : #endif
     513             : 
     514     3649719 :     av_buffer_unref(&frame->hw_frames_ctx);
     515             : 
     516     3649719 :     get_frame_defaults(frame);
     517             : }
     518             : 
     519     1162283 : void av_frame_move_ref(AVFrame *dst, AVFrame *src)
     520             : {
     521             :     av_assert1(dst->width == 0 && dst->height == 0);
     522             :     av_assert1(dst->channels == 0);
     523             : 
     524     1162283 :     *dst = *src;
     525     1162283 :     if (src->extended_data == src->data)
     526     1162283 :         dst->extended_data = dst->data;
     527     1162283 :     memset(src, 0, sizeof(*src));
     528     1162283 :     get_frame_defaults(src);
     529     1162283 : }
     530             : 
     531       15463 : int av_frame_is_writable(AVFrame *frame)
     532             : {
     533       15463 :     int i, ret = 1;
     534             : 
     535             :     /* assume non-refcounted frames are not writable */
     536       15463 :     if (!frame->buf[0])
     537           0 :         return 0;
     538             : 
     539      139167 :     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
     540      123704 :         if (frame->buf[i])
     541       31877 :             ret &= !!av_buffer_is_writable(frame->buf[i]);
     542       15463 :     for (i = 0; i < frame->nb_extended_buf; i++)
     543           0 :         ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
     544             : 
     545       15463 :     return ret;
     546             : }
     547             : 
     548        1595 : int av_frame_make_writable(AVFrame *frame)
     549             : {
     550             :     AVFrame tmp;
     551             :     int ret;
     552             : 
     553        1595 :     if (!frame->buf[0])
     554           0 :         return AVERROR(EINVAL);
     555             : 
     556        1595 :     if (av_frame_is_writable(frame))
     557         532 :         return 0;
     558             : 
     559        1063 :     memset(&tmp, 0, sizeof(tmp));
     560        1063 :     tmp.format         = frame->format;
     561        1063 :     tmp.width          = frame->width;
     562        1063 :     tmp.height         = frame->height;
     563        1063 :     tmp.channels       = frame->channels;
     564        1063 :     tmp.channel_layout = frame->channel_layout;
     565        1063 :     tmp.nb_samples     = frame->nb_samples;
     566        1063 :     ret = av_frame_get_buffer(&tmp, 32);
     567        1063 :     if (ret < 0)
     568           0 :         return ret;
     569             : 
     570        1063 :     ret = av_frame_copy(&tmp, frame);
     571        1063 :     if (ret < 0) {
     572           0 :         av_frame_unref(&tmp);
     573           0 :         return ret;
     574             :     }
     575             : 
     576        1063 :     ret = av_frame_copy_props(&tmp, frame);
     577        1063 :     if (ret < 0) {
     578           0 :         av_frame_unref(&tmp);
     579           0 :         return ret;
     580             :     }
     581             : 
     582        1063 :     av_frame_unref(frame);
     583             : 
     584        1063 :     *frame = tmp;
     585        1063 :     if (tmp.data == tmp.extended_data)
     586        1063 :         frame->extended_data = frame->data;
     587             : 
     588        1063 :     return 0;
     589             : }
     590             : 
     591      343692 : int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
     592             : {
     593      343692 :     return frame_copy_props(dst, src, 1);
     594             : }
     595             : 
     596        6195 : AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)
     597             : {
     598             :     uint8_t *data;
     599             :     int planes, i;
     600             : 
     601        6195 :     if (frame->nb_samples) {
     602        1295 :         int channels = frame->channels;
     603        1295 :         if (!channels)
     604           0 :             return NULL;
     605             :         CHECK_CHANNELS_CONSISTENCY(frame);
     606        1295 :         planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
     607             :     } else
     608        4900 :         planes = 4;
     609             : 
     610        6195 :     if (plane < 0 || plane >= planes || !frame->extended_data[plane])
     611           0 :         return NULL;
     612        6195 :     data = frame->extended_data[plane];
     613             : 
     614       14188 :     for (i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
     615       14188 :         AVBufferRef *buf = frame->buf[i];
     616       14188 :         if (data >= buf->data && data < buf->data + buf->size)
     617        6195 :             return buf;
     618             :     }
     619           0 :     for (i = 0; i < frame->nb_extended_buf; i++) {
     620           0 :         AVBufferRef *buf = frame->extended_buf[i];
     621           0 :         if (data >= buf->data && data < buf->data + buf->size)
     622           0 :             return buf;
     623             :     }
     624           0 :     return NULL;
     625             : }
     626             : 
     627       97884 : AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
     628             :                                         enum AVFrameSideDataType type,
     629             :                                         int size)
     630             : {
     631             :     AVFrameSideData *ret, **tmp;
     632             : 
     633       97884 :     if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
     634           0 :         return NULL;
     635             : 
     636       97884 :     tmp = av_realloc(frame->side_data,
     637       97884 :                      (frame->nb_side_data + 1) * sizeof(*frame->side_data));
     638       97884 :     if (!tmp)
     639           0 :         return NULL;
     640       97884 :     frame->side_data = tmp;
     641             : 
     642       97884 :     ret = av_mallocz(sizeof(*ret));
     643       97884 :     if (!ret)
     644           0 :         return NULL;
     645             : 
     646       97884 :     if (size > 0) {
     647       33923 :         ret->buf = av_buffer_alloc(size);
     648       33923 :         if (!ret->buf) {
     649           0 :             av_freep(&ret);
     650           0 :             return NULL;
     651             :         }
     652             : 
     653       33923 :         ret->data = ret->buf->data;
     654       33923 :         ret->size = size;
     655             :     }
     656       97884 :     ret->type = type;
     657             : 
     658       97884 :     frame->side_data[frame->nb_side_data++] = ret;
     659             : 
     660       97884 :     return ret;
     661             : }
     662             : 
     663      318398 : AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
     664             :                                         enum AVFrameSideDataType type)
     665             : {
     666             :     int i;
     667             : 
     668      342579 :     for (i = 0; i < frame->nb_side_data; i++) {
     669       24208 :         if (frame->side_data[i]->type == type)
     670          27 :             return frame->side_data[i];
     671             :     }
     672      318371 :     return NULL;
     673             : }
     674             : 
     675        3121 : static int frame_copy_video(AVFrame *dst, const AVFrame *src)
     676             : {
     677             :     const uint8_t *src_data[4];
     678             :     int i, planes;
     679             : 
     680        6242 :     if (dst->width  < src->width ||
     681        3121 :         dst->height < src->height)
     682           0 :         return AVERROR(EINVAL);
     683             : 
     684        3121 :     planes = av_pix_fmt_count_planes(dst->format);
     685        9638 :     for (i = 0; i < planes; i++)
     686        6517 :         if (!dst->data[i] || !src->data[i])
     687           0 :             return AVERROR(EINVAL);
     688             : 
     689        3121 :     memcpy(src_data, src->data, sizeof(src_data));
     690        6242 :     av_image_copy(dst->data, dst->linesize,
     691        3121 :                   src_data, src->linesize,
     692        3121 :                   dst->format, src->width, src->height);
     693             : 
     694        3121 :     return 0;
     695             : }
     696             : 
     697           0 : static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
     698             : {
     699           0 :     int planar   = av_sample_fmt_is_planar(dst->format);
     700           0 :     int channels = dst->channels;
     701           0 :     int planes   = planar ? channels : 1;
     702             :     int i;
     703             : 
     704           0 :     if (dst->nb_samples     != src->nb_samples ||
     705           0 :         dst->channels       != src->channels ||
     706           0 :         dst->channel_layout != src->channel_layout)
     707           0 :         return AVERROR(EINVAL);
     708             : 
     709             :     CHECK_CHANNELS_CONSISTENCY(src);
     710             : 
     711           0 :     for (i = 0; i < planes; i++)
     712           0 :         if (!dst->extended_data[i] || !src->extended_data[i])
     713           0 :             return AVERROR(EINVAL);
     714             : 
     715           0 :     av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
     716           0 :                     dst->nb_samples, channels, dst->format);
     717             : 
     718           0 :     return 0;
     719             : }
     720             : 
     721        3121 : int av_frame_copy(AVFrame *dst, const AVFrame *src)
     722             : {
     723        3121 :     if (dst->format != src->format || dst->format < 0)
     724           0 :         return AVERROR(EINVAL);
     725             : 
     726        3121 :     if (dst->width > 0 && dst->height > 0)
     727        3121 :         return frame_copy_video(dst, src);
     728           0 :     else if (dst->nb_samples > 0 && dst->channel_layout)
     729           0 :         return frame_copy_audio(dst, src);
     730             : 
     731           0 :     return AVERROR(EINVAL);
     732             : }
     733             : 
     734           0 : void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
     735             : {
     736             :     int i;
     737             : 
     738           0 :     for (i = 0; i < frame->nb_side_data; i++) {
     739           0 :         AVFrameSideData *sd = frame->side_data[i];
     740           0 :         if (sd->type == type) {
     741           0 :             free_side_data(&frame->side_data[i]);
     742           0 :             frame->side_data[i] = frame->side_data[frame->nb_side_data - 1];
     743           0 :             frame->nb_side_data--;
     744             :         }
     745             :     }
     746           0 : }
     747             : 
     748           0 : const char *av_frame_side_data_name(enum AVFrameSideDataType type)
     749             : {
     750           0 :     switch(type) {
     751           0 :     case AV_FRAME_DATA_PANSCAN:         return "AVPanScan";
     752           0 :     case AV_FRAME_DATA_A53_CC:          return "ATSC A53 Part 4 Closed Captions";
     753           0 :     case AV_FRAME_DATA_STEREO3D:        return "Stereoscopic 3d metadata";
     754           0 :     case AV_FRAME_DATA_MATRIXENCODING:  return "AVMatrixEncoding";
     755           0 :     case AV_FRAME_DATA_DOWNMIX_INFO:    return "Metadata relevant to a downmix procedure";
     756           0 :     case AV_FRAME_DATA_REPLAYGAIN:      return "AVReplayGain";
     757           0 :     case AV_FRAME_DATA_DISPLAYMATRIX:   return "3x3 displaymatrix";
     758           0 :     case AV_FRAME_DATA_AFD:             return "Active format description";
     759           0 :     case AV_FRAME_DATA_MOTION_VECTORS:  return "Motion vectors";
     760           0 :     case AV_FRAME_DATA_SKIP_SAMPLES:    return "Skip samples";
     761           0 :     case AV_FRAME_DATA_AUDIO_SERVICE_TYPE:          return "Audio service type";
     762           0 :     case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA:  return "Mastering display metadata";
     763           0 :     case AV_FRAME_DATA_GOP_TIMECODE:                return "GOP timecode";
     764             :     }
     765           0 :     return NULL;
     766             : }

Generated by: LCOV version 1.12