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                 av_fifo_freep(&af->buf[i]);
  52             }
  53             av_freep(&af->buf);
  54         }
  55         av_free(af);
  56     }
  57 }
  58
  59 AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels,
  60                                  int nb_samples)
  61 {
  62     AVAudioFifo *af;
  63     int buf_size, i;
  64
  65     /* get channel buffer size (also validates parameters) */
  66     if (av_samples_get_buffer_size(&buf_size, channels, nb_samples, sample_fmt, 1) < 0)
  67         return NULL;
  68
  69     af = av_mallocz(sizeof(*af));
  70     if (!af)
  71         return NULL;
  72
  73     af->channels    = channels;
  74     af->sample_fmt  = sample_fmt;
  75     af->sample_size = buf_size / nb_samples;
  76     af->nb_buffers  = av_sample_fmt_is_planar(sample_fmt) ? channels : 1;
  77
  78     af->buf = av_mallocz_array(af->nb_buffers, sizeof(*af->buf));
  79     if (!af->buf)
  80         goto error;
  81
  82     for (i = 0; i < af->nb_buffers; i++) {
  83         af->buf[i] = av_fifo_alloc(buf_size);
  84         if (!af->buf[i])
  85             goto error;
  86     }
  87     af->allocated_samples = nb_samples;
  88
  89     return af;
  90
  91 error:
  92     av_audio_fifo_free(af);
  93     return NULL;
  94 }
  95
  96 int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
  97 {
  98     int i, ret, buf_size;
  99
 100     if ((ret = av_samples_get_buffer_size(&buf_size, af->channels, nb_samples,
 101                                           af->sample_fmt, 1)) < 0)
 102         return ret;
 103
 104     for (i = 0; i < af->nb_buffers; i++) {
 105         if ((ret = av_fifo_realloc2(af->buf[i], buf_size)) < 0)
 106             return ret;
 107     }
 108     af->allocated_samples = nb_samples;
 109     return 0;
 110 }
 111
 112 int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
 113 {
 114     int i, ret, size;
 115
 116     /* automatically reallocate buffers if needed */
 117     if (av_audio_fifo_space(af) < nb_samples) {
 118         int current_size = av_audio_fifo_size(af);
 119         /* check for integer overflow in new size calculation */
 120         if (INT_MAX / 2 - current_size < nb_samples)
 121             return AVERROR(EINVAL);
 122         /* reallocate buffers */
 123         if ((ret = av_audio_fifo_realloc(af, 2 * (current_size + nb_samples))) < 0)
 124             return ret;
 125     }
 126
 127     size = nb_samples * af->sample_size;
 128     for (i = 0; i < af->nb_buffers; i++) {
 129         ret = av_fifo_generic_write(af->buf[i], data[i], size, NULL);
 130         if (ret != size)
 131             return AVERROR_BUG;
 132     }
 133     af->nb_samples += nb_samples;
 134
 135     return nb_samples;
 136 }
 137
 138 int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
 139 {
 140     int i, ret, size;
 141
 142     if (nb_samples < 0)
 143         return AVERROR(EINVAL);
 144     nb_samples = FFMIN(nb_samples, af->nb_samples);
 145     if (!nb_samples)
 146         return 0;
 147
 148     size = nb_samples * af->sample_size;
 149     for (i = 0; i < af->nb_buffers; i++) {
 150         if ((ret = av_fifo_generic_peek(af->buf[i], data[i], size, NULL)) < 0)
 151             return AVERROR_BUG;
 152     }
 153
 154     return nb_samples;
 155 }
 156
 157 int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset)
 158 {
 159     int i, ret, size;
 160
 161     if (offset < 0 || offset >= af->nb_samples)
 162         return AVERROR(EINVAL);
 163     if (nb_samples < 0)
 164         return AVERROR(EINVAL);
 165     nb_samples = FFMIN(nb_samples, af->nb_samples);
 166     if (!nb_samples)
 167         return 0;
 168     if (offset > af->nb_samples - nb_samples)
 169         return AVERROR(EINVAL);
 170
 171     offset *= af->sample_size;
 172     size = nb_samples * af->sample_size;
 173     for (i = 0; i < af->nb_buffers; i++) {
 174         if ((ret = av_fifo_generic_peek_at(af->buf[i], data[i], offset, size, NULL)) < 0)
 175             return AVERROR_BUG;
 176     }
 177
 178     return nb_samples;
 179 }
 180
 181 int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
 182 {
 183     int i, size;
 184
 185     if (nb_samples < 0)
 186         return AVERROR(EINVAL);
 187     nb_samples = FFMIN(nb_samples, af->nb_samples);
 188     if (!nb_samples)
 189         return 0;
 190
 191     size = nb_samples * af->sample_size;
 192     for (i = 0; i < af->nb_buffers; i++) {
 193         if (av_fifo_generic_read(af->buf[i], data[i], size, NULL) < 0)
 194             return AVERROR_BUG;
 195     }
 196     af->nb_samples -= nb_samples;
 197
 198     return nb_samples;
 199 }
 200
 201 int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
 202 {
 203     int i, size;
 204
 205     if (nb_samples < 0)
 206         return AVERROR(EINVAL);
 207     nb_samples = FFMIN(nb_samples, af->nb_samples);
 208
 209     if (nb_samples) {
 210         size = nb_samples * af->sample_size;
 211         for (i = 0; i < af->nb_buffers; i++)
 212             av_fifo_drain(af->buf[i], size);
 213         af->nb_samples -= nb_samples;
 214     }
 215     return 0;
 216 }
 217
 218 void av_audio_fifo_reset(AVAudioFifo *af)
 219 {
 220     int i;
 221
 222     for (i = 0; i < af->nb_buffers; i++)
 223         av_fifo_reset(af->buf[i]);
 224
 225     af->nb_samples = 0;
 226 }
 227
 228 int av_audio_fifo_size(AVAudioFifo *af)
 229 {
 230     return af->nb_samples;
 231 }
 232
 233 int av_audio_fifo_space(AVAudioFifo *af)
 234 {
 235     return af->allocated_samples - af->nb_samples;
 236 }