git.sesse.net Git - ffmpeg/blob - libavutil/samplefmt.c

   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 "samplefmt.h"
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 typedef struct SampleFmtInfo {
  26     char name[4];
  27     int bits;
  28     int planar;
  29     enum AVSampleFormat altform; ///< planar<->packed alternative form
  30 } SampleFmtInfo;
  31
  32 /** this table gives more information about formats */
  33 static const SampleFmtInfo sample_fmt_info[AV_SAMPLE_FMT_NB] = {
  34     [AV_SAMPLE_FMT_U8]   = { .name =   "u8", .bits =  8, .planar = 0, .altform = AV_SAMPLE_FMT_U8P  },
  35     [AV_SAMPLE_FMT_S16]  = { .name =  "s16", .bits = 16, .planar = 0, .altform = AV_SAMPLE_FMT_S16P },
  36     [AV_SAMPLE_FMT_S32]  = { .name =  "s32", .bits = 32, .planar = 0, .altform = AV_SAMPLE_FMT_S32P },
  37     [AV_SAMPLE_FMT_FLT]  = { .name =  "flt", .bits = 32, .planar = 0, .altform = AV_SAMPLE_FMT_FLTP },
  38     [AV_SAMPLE_FMT_DBL]  = { .name =  "dbl", .bits = 64, .planar = 0, .altform = AV_SAMPLE_FMT_DBLP },
  39     [AV_SAMPLE_FMT_U8P]  = { .name =  "u8p", .bits =  8, .planar = 1, .altform = AV_SAMPLE_FMT_U8   },
  40     [AV_SAMPLE_FMT_S16P] = { .name = "s16p", .bits = 16, .planar = 1, .altform = AV_SAMPLE_FMT_S16  },
  41     [AV_SAMPLE_FMT_S32P] = { .name = "s32p", .bits = 32, .planar = 1, .altform = AV_SAMPLE_FMT_S32  },
  42     [AV_SAMPLE_FMT_FLTP] = { .name = "fltp", .bits = 32, .planar = 1, .altform = AV_SAMPLE_FMT_FLT  },
  43     [AV_SAMPLE_FMT_DBLP] = { .name = "dblp", .bits = 64, .planar = 1, .altform = AV_SAMPLE_FMT_DBL  },
  44 };
  45
  46 const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
  47 {
  48     if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
  49         return NULL;
  50     return sample_fmt_info[sample_fmt].name;
  51 }
  52
  53 enum AVSampleFormat av_get_sample_fmt(const char *name)
  54 {
  55     int i;
  56
  57     for (i = 0; i < AV_SAMPLE_FMT_NB; i++)
  58         if (!strcmp(sample_fmt_info[i].name, name))
  59             return i;
  60     return AV_SAMPLE_FMT_NONE;
  61 }
  62
  63 enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar)
  64 {
  65     if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
  66         return AV_SAMPLE_FMT_NONE;
  67     if (sample_fmt_info[sample_fmt].planar == planar)
  68         return sample_fmt;
  69     return sample_fmt_info[sample_fmt].altform;
  70 }
  71
  72 char *av_get_sample_fmt_string (char *buf, int buf_size, enum AVSampleFormat sample_fmt)
  73 {
  74     /* print header */
  75     if (sample_fmt < 0)
  76         snprintf(buf, buf_size, "name  " " depth");
  77     else if (sample_fmt < AV_SAMPLE_FMT_NB) {
  78         SampleFmtInfo info = sample_fmt_info[sample_fmt];
  79         snprintf (buf, buf_size, "%-6s" "   %2d ", info.name, info.bits);
  80     }
  81
  82     return buf;
  83 }
  84
  85 int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
  86 {
  87      return sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB ?
  88         0 : sample_fmt_info[sample_fmt].bits >> 3;
  89 }
  90
  91 #if FF_API_GET_BITS_PER_SAMPLE_FMT
  92 int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt)
  93 {
  94     return sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB ?
  95         0 : sample_fmt_info[sample_fmt].bits;
  96 }
  97 #endif
  98
  99 int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
 100 {
 101      if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
 102          return 0;
 103      return sample_fmt_info[sample_fmt].planar;
 104 }
 105
 106 int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
 107                                enum AVSampleFormat sample_fmt, int align)
 108 {
 109     int line_size;
 110     int sample_size = av_get_bytes_per_sample(sample_fmt);
 111     int planar      = av_sample_fmt_is_planar(sample_fmt);
 112
 113     /* validate parameter ranges */
 114     if (!sample_size || nb_samples <= 0 || nb_channels <= 0)
 115         return AVERROR(EINVAL);
 116
 117     /* check for integer overflow */
 118     if (nb_channels > INT_MAX / align ||
 119         (int64_t)nb_channels * nb_samples > (INT_MAX - (align * nb_channels)) / sample_size)
 120         return AVERROR(EINVAL);
 121
 122     line_size = planar ? FFALIGN(nb_samples * sample_size,               align) :
 123                          FFALIGN(nb_samples * sample_size * nb_channels, align);
 124     if (linesize)
 125         *linesize = line_size;
 126
 127     return planar ? line_size * nb_channels : line_size;
 128 }
 129
 130 int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
 131                            uint8_t *buf, int nb_channels, int nb_samples,
 132                            enum AVSampleFormat sample_fmt, int align)
 133 {
 134     int ch, planar, buf_size;
 135
 136     planar   = av_sample_fmt_is_planar(sample_fmt);
 137     buf_size = av_samples_get_buffer_size(linesize, nb_channels, nb_samples,
 138                                           sample_fmt, align);
 139     if (buf_size < 0)
 140         return buf_size;
 141
 142     audio_data[0] = buf;
 143     for (ch = 1; planar && ch < nb_channels; ch++)
 144         audio_data[ch] = audio_data[ch-1] + *linesize;
 145
 146     return 0;
 147 }
 148
 149 int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
 150                      int nb_samples, enum AVSampleFormat sample_fmt, int align)
 151 {
 152     uint8_t *buf;
 153     int size = av_samples_get_buffer_size(NULL, nb_channels, nb_samples,
 154                                           sample_fmt, align);
 155     if (size < 0)
 156         return size;
 157
 158     buf = av_mallocz(size);
 159     if (!buf)
 160         return AVERROR(ENOMEM);
 161
 162     size = av_samples_fill_arrays(audio_data, linesize, buf, nb_channels,
 163                                   nb_samples, sample_fmt, align);
 164     if (size < 0) {
 165         av_free(buf);
 166         return size;
 167     }
 168     return 0;
 169 }