avutil/tests/audio_fifo.c: pass by reference for efficiency and change datatype to...
[ffmpeg.git] / 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, ret, 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 ((ret = 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 }