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

   1 /*
   2  * Audio FIFO
   3  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * Audio FIFO
  25  */
  26
  27 #include "avutil.h"
  28 #include "audio_fifo.h"
  29 #include "common.h"
  30 #include "fifo.h"
  31 #include "mem.h"
  32 #include "samplefmt.h"
  33
  34 struct AVAudioFifo {
  35     AVFifoBuffer **buf;             /**< single buffer for interleaved, per-channel buffers for planar */
  36     int nb_buffers;                 /**< number of buffers */
  37     int nb_samples;                 /**< number of samples currently in the FIFO */
  38     int allocated_samples;          /**< current allocated size, in samples */
  39
  40     int channels;                   /**< number of channels */
  41     enum AVSampleFormat sample_fmt; /**< sample format */
  42     int sample_size;                /**< size, in bytes, of one sample in a buffer */
  43 };
  44
  45 void av_audio_fifo_free(AVAudioFifo *af)
  46 {
  47     if (af) {
  48         if (af->buf) {
  49             int i;
  50             for (i = 0; i < af->nb_buffers; i++) {
  51                 if (af->buf[i])
  52                     av_fifo_free(af->buf[i]);
  53             }
  54             av_freep(&af->buf);
  55         }
  56         av_free(af);
  57     }
  58 }
  59
  60 AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels,
  61                                  int nb_samples)
  62 {
  63     AVAudioFifo *af;
  64     int buf_size, i;
  65
  66     /* get channel buffer size (also validates parameters) */
  67     if (av_samples_get_buffer_size(&buf_size, channels, nb_samples, sample_fmt, 1) < 0)
  68         return NULL;
  69
  70     af = av_mallocz(sizeof(*af));
  71     if (!af)
  72         return NULL;
  73
  74     af->channels    = channels;
  75     af->sample_fmt  = sample_fmt;
  76     af->sample_size = buf_size / nb_samples;
  77     af->nb_buffers  = av_sample_fmt_is_planar(sample_fmt) ? channels : 1;
  78
  79     af->buf = av_mallocz_array(af->nb_buffers, sizeof(*af->buf));
  80     if (!af->buf)
  81         goto error;
  82
  83     for (i = 0; i < af->nb_buffers; i++) {
  84         af->buf[i] = av_fifo_alloc(buf_size);
  85         if (!af->buf[i])
  86             goto error;
  87     }
  88     af->allocated_samples = nb_samples;
  89
  90     return af;
  91
  92 error:
  93     av_audio_fifo_free(af);
  94     return NULL;
  95 }
  96
  97 int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
  98 {
  99     int i, ret, buf_size;
 100
 101     if ((ret = av_samples_get_buffer_size(&buf_size, af->channels, nb_samples,
 102                                           af->sample_fmt, 1)) < 0)
 103         return ret;
 104
 105     for (i = 0; i < af->nb_buffers; i++) {
 106         if ((ret = av_fifo_realloc2(af->buf[i], buf_size)) < 0)
 107             return ret;
 108     }
 109     af->allocated_samples = nb_samples;
 110     return 0;
 111 }
 112
 113 int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
 114 {
 115     int i, ret, size;
 116
 117     /* automatically reallocate buffers if needed */
 118     if (av_audio_fifo_space(af) < nb_samples) {
 119         int current_size = av_audio_fifo_size(af);
 120         /* check for integer overflow in new size calculation */
 121         if (INT_MAX / 2 - current_size < nb_samples)
 122             return AVERROR(EINVAL);
 123         /* reallocate buffers */
 124         if ((ret = av_audio_fifo_realloc(af, 2 * (current_size + nb_samples))) < 0)
 125             return ret;
 126     }
 127
 128     size = nb_samples * af->sample_size;
 129     for (i = 0; i < af->nb_buffers; i++) {
 130         ret = av_fifo_generic_write(af->buf[i], data[i], size, NULL);
 131         if (ret != size)
 132             return AVERROR_BUG;
 133     }
 134     af->nb_samples += nb_samples;
 135
 136     return nb_samples;
 137 }
 138
 139 int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
 140 {
 141     int i, ret, size;
 142
 143     if (nb_samples < 0)
 144         return AVERROR(EINVAL);
 145     nb_samples = FFMIN(nb_samples, af->nb_samples);
 146     if (!nb_samples)
 147         return 0;
 148
 149     size = nb_samples * af->sample_size;
 150     for (i = 0; i < af->nb_buffers; i++) {
 151         if ((ret = av_fifo_generic_peek(af->buf[i], data[i], size, NULL)) < 0)
 152             return AVERROR_BUG;
 153     }
 154
 155     return nb_samples;
 156 }
 157
 158 int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset)
 159 {
 160     int i, ret, size;
 161
 162     if (offset < 0 || offset >= af->nb_samples)
 163         return AVERROR(EINVAL);
 164     if (nb_samples < 0)
 165         return AVERROR(EINVAL);
 166     nb_samples = FFMIN(nb_samples, af->nb_samples);
 167     if (!nb_samples)
 168         return 0;
 169     if (offset > af->nb_samples - nb_samples)
 170         return AVERROR(EINVAL);
 171
 172     offset *= af->sample_size;
 173     size = nb_samples * af->sample_size;
 174     for (i = 0; i < af->nb_buffers; i++) {
 175         if ((ret = av_fifo_generic_peek_at(af->buf[i], data[i], offset, size, NULL)) < 0)
 176             return AVERROR_BUG;
 177     }
 178
 179     return nb_samples;
 180 }
 181
 182 int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
 183 {
 184     int i, ret, size;
 185
 186     if (nb_samples < 0)
 187         return AVERROR(EINVAL);
 188     nb_samples = FFMIN(nb_samples, af->nb_samples);
 189     if (!nb_samples)
 190         return 0;
 191
 192     size = nb_samples * af->sample_size;
 193     for (i = 0; i < af->nb_buffers; i++) {
 194         if ((ret = av_fifo_generic_read(af->buf[i], data[i], size, NULL)) < 0)
 195             return AVERROR_BUG;
 196     }
 197     af->nb_samples -= nb_samples;
 198
 199     return nb_samples;
 200 }
 201
 202 int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
 203 {
 204     int i, size;
 205
 206     if (nb_samples < 0)
 207         return AVERROR(EINVAL);
 208     nb_samples = FFMIN(nb_samples, af->nb_samples);
 209
 210     if (nb_samples) {
 211         size = nb_samples * af->sample_size;
 212         for (i = 0; i < af->nb_buffers; i++)
 213             av_fifo_drain(af->buf[i], size);
 214         af->nb_samples -= nb_samples;
 215     }
 216     return 0;
 217 }
 218
 219 void av_audio_fifo_reset(AVAudioFifo *af)
 220 {
 221     int i;
 222
 223     for (i = 0; i < af->nb_buffers; i++)
 224         av_fifo_reset(af->buf[i]);
 225
 226     af->nb_samples = 0;
 227 }
 228
 229 int av_audio_fifo_size(AVAudioFifo *af)
 230 {
 231     return af->nb_samples;
 232 }
 233
 234 int av_audio_fifo_space(AVAudioFifo *af)
 235 {
 236     return af->allocated_samples - af->nb_samples;
 237 }