code.delx.au - pulseaudio/blob - src/pulse/sample.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include <pulse/timeval.h>
  31
  32 #include <pulsecore/core-util.h>
  33 #include <pulsecore/i18n.h>
  34 #include <pulsecore/macro.h>
  35
  36 #include "sample.h"
  37
  38 static const size_t size_table[] = {
  39     [PA_SAMPLE_U8] = 1,
  40     [PA_SAMPLE_ULAW] = 1,
  41     [PA_SAMPLE_ALAW] = 1,
  42     [PA_SAMPLE_S16LE] = 2,
  43     [PA_SAMPLE_S16BE] = 2,
  44     [PA_SAMPLE_FLOAT32LE] = 4,
  45     [PA_SAMPLE_FLOAT32BE] = 4,
  46     [PA_SAMPLE_S32LE] = 4,
  47     [PA_SAMPLE_S32BE] = 4,
  48     [PA_SAMPLE_S24LE] = 3,
  49     [PA_SAMPLE_S24BE] = 3,
  50     [PA_SAMPLE_S24_32LE] = 4,
  51     [PA_SAMPLE_S24_32BE] = 4
  52 };
  53
  54 size_t pa_sample_size_of_format(pa_sample_format_t f) {
  55     pa_assert(pa_sample_format_valid(f));
  56
  57     return size_table[f];
  58 }
  59
  60 size_t pa_sample_size(const pa_sample_spec *spec) {
  61
  62     pa_assert(spec);
  63     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
  64
  65     return size_table[spec->format];
  66 }
  67
  68 size_t pa_frame_size(const pa_sample_spec *spec) {
  69     pa_assert(spec);
  70     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
  71
  72     return size_table[spec->format] * spec->channels;
  73 }
  74
  75 size_t pa_bytes_per_second(const pa_sample_spec *spec) {
  76     pa_assert(spec);
  77     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
  78
  79     return spec->rate * size_table[spec->format] * spec->channels;
  80 }
  81
  82 pa_usec_t pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec) {
  83     pa_assert(spec);
  84     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
  85
  86     return (((pa_usec_t) (length / (size_table[spec->format] * spec->channels)) * PA_USEC_PER_SEC) / spec->rate);
  87 }
  88
  89 size_t pa_usec_to_bytes(pa_usec_t t, const pa_sample_spec *spec) {
  90     pa_assert(spec);
  91     pa_return_val_if_fail(pa_sample_spec_valid(spec), 0);
  92
  93     return (size_t) (((t * spec->rate) / PA_USEC_PER_SEC)) * (size_table[spec->format] * spec->channels);
  94 }
  95
  96 pa_sample_spec* pa_sample_spec_init(pa_sample_spec *spec) {
  97     pa_assert(spec);
  98
  99     spec->format = PA_SAMPLE_INVALID;
 100     spec->rate = 0;
 101     spec->channels = 0;
 102
 103     return spec;
 104 }
 105
 106 int pa_sample_format_valid(unsigned format) {
 107     return format < PA_SAMPLE_MAX;
 108 }
 109
 110 int pa_sample_rate_valid(uint32_t rate) {
 111     return rate > 0 && rate <= PA_RATE_MAX;
 112 }
 113
 114 int pa_channels_valid(uint8_t channels) {
 115     return channels > 0 && channels <= PA_CHANNELS_MAX;
 116 }
 117
 118 int pa_sample_spec_valid(const pa_sample_spec *spec) {
 119     pa_assert(spec);
 120
 121     if (PA_UNLIKELY(!pa_sample_rate_valid(spec->rate) ||
 122         !pa_channels_valid(spec->channels) ||
 123         !pa_sample_format_valid(spec->format)))
 124         return 0;
 125
 126     return 1;
 127 }
 128
 129 int pa_sample_spec_equal(const pa_sample_spec*a, const pa_sample_spec*b) {
 130     pa_assert(a);
 131     pa_assert(b);
 132
 133     pa_return_val_if_fail(pa_sample_spec_valid(a), 0);
 134
 135     if (PA_UNLIKELY(a == b))
 136         return 1;
 137
 138     pa_return_val_if_fail(pa_sample_spec_valid(b), 0);
 139
 140     return
 141         (a->format == b->format) &&
 142         (a->rate == b->rate) &&
 143         (a->channels == b->channels);
 144 }
 145
 146 const char *pa_sample_format_to_string(pa_sample_format_t f) {
 147     static const char* const table[]= {
 148         [PA_SAMPLE_U8] = "u8",
 149         [PA_SAMPLE_ALAW] = "aLaw",
 150         [PA_SAMPLE_ULAW] = "uLaw",
 151         [PA_SAMPLE_S16LE] = "s16le",
 152         [PA_SAMPLE_S16BE] = "s16be",
 153         [PA_SAMPLE_FLOAT32LE] = "float32le",
 154         [PA_SAMPLE_FLOAT32BE] = "float32be",
 155         [PA_SAMPLE_S32LE] = "s32le",
 156         [PA_SAMPLE_S32BE] = "s32be",
 157         [PA_SAMPLE_S24LE] = "s24le",
 158         [PA_SAMPLE_S24BE] = "s24be",
 159         [PA_SAMPLE_S24_32LE] = "s24-32le",
 160         [PA_SAMPLE_S24_32BE] = "s24-32be",
 161     };
 162
 163     if (!pa_sample_format_valid(f))
 164         return NULL;
 165
 166     return table[f];
 167 }
 168
 169 char *pa_sample_spec_snprint(char *s, size_t l, const pa_sample_spec *spec) {
 170     pa_assert(s);
 171     pa_assert(l > 0);
 172     pa_assert(spec);
 173
 174     pa_init_i18n();
 175
 176     if (!pa_sample_spec_valid(spec))
 177         pa_snprintf(s, l, _("(invalid)"));
 178     else
 179         pa_snprintf(s, l, _("%s %uch %uHz"), pa_sample_format_to_string(spec->format), spec->channels, spec->rate);
 180
 181     return s;
 182 }
 183
 184 char* pa_bytes_snprint(char *s, size_t l, unsigned v) {
 185     pa_assert(s);
 186     pa_assert(l > 0);
 187
 188     pa_init_i18n();
 189
 190     if (v >= ((unsigned) 1024)*1024*1024)
 191         pa_snprintf(s, l, _("%0.1f GiB"), ((double) v)/1024/1024/1024);
 192     else if (v >= ((unsigned) 1024)*1024)
 193         pa_snprintf(s, l, _("%0.1f MiB"), ((double) v)/1024/1024);
 194     else if (v >= (unsigned) 1024)
 195         pa_snprintf(s, l, _("%0.1f KiB"), ((double) v)/1024);
 196     else
 197         pa_snprintf(s, l, _("%u B"), (unsigned) v);
 198
 199     return s;
 200 }
 201
 202 pa_sample_format_t pa_parse_sample_format(const char *format) {
 203     pa_assert(format);
 204
 205     if (strcasecmp(format, "s16le") == 0)
 206         return PA_SAMPLE_S16LE;
 207     else if (strcasecmp(format, "s16be") == 0)
 208         return PA_SAMPLE_S16BE;
 209     else if (strcasecmp(format, "s16ne") == 0 || strcasecmp(format, "s16") == 0 || strcasecmp(format, "16") == 0)
 210         return PA_SAMPLE_S16NE;
 211     else if (strcasecmp(format, "s16re") == 0)
 212         return PA_SAMPLE_S16RE;
 213     else if (strcasecmp(format, "u8") == 0 || strcasecmp(format, "8") == 0)
 214         return PA_SAMPLE_U8;
 215     else if (strcasecmp(format, "float32") == 0 || strcasecmp(format, "float32ne") == 0 || strcasecmp(format, "float") == 0)
 216         return PA_SAMPLE_FLOAT32NE;
 217     else if (strcasecmp(format, "float32re") == 0)
 218         return PA_SAMPLE_FLOAT32RE;
 219     else if (strcasecmp(format, "float32le") == 0)
 220         return PA_SAMPLE_FLOAT32LE;
 221     else if (strcasecmp(format, "float32be") == 0)
 222         return PA_SAMPLE_FLOAT32BE;
 223     else if (strcasecmp(format, "ulaw") == 0 || strcasecmp(format, "mulaw") == 0)
 224         return PA_SAMPLE_ULAW;
 225     else if (strcasecmp(format, "alaw") == 0)
 226         return PA_SAMPLE_ALAW;
 227     else if (strcasecmp(format, "s32le") == 0)
 228         return PA_SAMPLE_S32LE;
 229     else if (strcasecmp(format, "s32be") == 0)
 230         return PA_SAMPLE_S32BE;
 231     else if (strcasecmp(format, "s32ne") == 0 || strcasecmp(format, "s32") == 0 || strcasecmp(format, "32") == 0)
 232         return PA_SAMPLE_S32NE;
 233     else if (strcasecmp(format, "s32re") == 0)
 234         return PA_SAMPLE_S24RE;
 235     else if (strcasecmp(format, "s24le") == 0)
 236         return PA_SAMPLE_S24LE;
 237     else if (strcasecmp(format, "s24be") == 0)
 238         return PA_SAMPLE_S24BE;
 239     else if (strcasecmp(format, "s24ne") == 0 || strcasecmp(format, "s24") == 0 || strcasecmp(format, "24") == 0)
 240         return PA_SAMPLE_S24NE;
 241     else if (strcasecmp(format, "s24re") == 0)
 242         return PA_SAMPLE_S24RE;
 243     else if (strcasecmp(format, "s24-32le") == 0)
 244         return PA_SAMPLE_S24_32LE;
 245     else if (strcasecmp(format, "s24-32be") == 0)
 246         return PA_SAMPLE_S24_32BE;
 247     else if (strcasecmp(format, "s24-32ne") == 0 || strcasecmp(format, "s24-32") == 0)
 248         return PA_SAMPLE_S24_32NE;
 249     else if (strcasecmp(format, "s24-32re") == 0)
 250         return PA_SAMPLE_S24_32RE;
 251
 252     return PA_SAMPLE_INVALID;
 253 }
 254
 255 int pa_sample_format_is_le(pa_sample_format_t f) {
 256     pa_assert(pa_sample_format_valid(f));
 257
 258     switch (f) {
 259         case PA_SAMPLE_S16LE:
 260         case PA_SAMPLE_S24LE:
 261         case PA_SAMPLE_S32LE:
 262         case PA_SAMPLE_S24_32LE:
 263         case PA_SAMPLE_FLOAT32LE:
 264             return 1;
 265
 266         case PA_SAMPLE_S16BE:
 267         case PA_SAMPLE_S24BE:
 268         case PA_SAMPLE_S32BE:
 269         case PA_SAMPLE_S24_32BE:
 270         case PA_SAMPLE_FLOAT32BE:
 271             return 0;
 272
 273         default:
 274             return -1;
 275     }
 276 }
 277
 278 int pa_sample_format_is_be(pa_sample_format_t f) {
 279     int r;
 280
 281     if ((r = pa_sample_format_is_le(f)) < 0)
 282         return r;
 283
 284     return !r;
 285 }