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 <limits.h>
28 #include <stddef.h>
29
30 #include "audio_fifo.h"
31 #include "error.h"
32 #include "fifo.h"
33 #include "macros.h"
34 #include "mem.h"
35 #include "samplefmt.h"
36
37 struct AVAudioFifo {
38 AVFifo **buf; /**< single buffer for interleaved, per-channel buffers for planar */
39 int nb_buffers; /**< number of buffers */
40 int nb_samples; /**< number of samples currently in the FIFO */
41 int allocated_samples; /**< current allocated size, in samples */
42
43 int channels; /**< number of channels */
44 enum AVSampleFormat sample_fmt; /**< sample format */
45 int sample_size; /**< size, in bytes, of one sample in a buffer */
46 };
47
av_audio_fifo_free(AVAudioFifo * af)48 void av_audio_fifo_free(AVAudioFifo *af)
49 {
50 if (af) {
51 if (af->buf) {
52 int i;
53 for (i = 0; i < af->nb_buffers; i++) {
54 av_fifo_freep2(&af->buf[i]);
55 }
56 av_freep(&af->buf);
57 }
58 av_free(af);
59 }
60 }
61
av_audio_fifo_alloc(enum AVSampleFormat sample_fmt,int channels,int nb_samples)62 AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels,
63 int nb_samples)
64 {
65 AVAudioFifo *af;
66 int buf_size, i;
67
68 /* get channel buffer size (also validates parameters) */
69 if (av_samples_get_buffer_size(&buf_size, channels, nb_samples, sample_fmt, 1) < 0)
70 return NULL;
71
72 af = av_mallocz(sizeof(*af));
73 if (!af)
74 return NULL;
75
76 af->channels = channels;
77 af->sample_fmt = sample_fmt;
78 af->sample_size = buf_size / nb_samples;
79 af->nb_buffers = av_sample_fmt_is_planar(sample_fmt) ? channels : 1;
80
81 af->buf = av_calloc(af->nb_buffers, sizeof(*af->buf));
82 if (!af->buf)
83 goto error;
84
85 for (i = 0; i < af->nb_buffers; i++) {
86 af->buf[i] = av_fifo_alloc2(buf_size, 1, 0);
87 if (!af->buf[i])
88 goto error;
89 }
90 af->allocated_samples = nb_samples;
91
92 return af;
93
94 error:
95 av_audio_fifo_free(af);
96 return NULL;
97 }
98
av_audio_fifo_realloc(AVAudioFifo * af,int nb_samples)99 int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
100 {
101 const size_t cur_size = av_fifo_can_read (af->buf[0]) +
102 av_fifo_can_write(af->buf[0]);
103 int i, ret, buf_size;
104
105 if ((ret = av_samples_get_buffer_size(&buf_size, af->channels, nb_samples,
106 af->sample_fmt, 1)) < 0)
107 return ret;
108
109 if (buf_size > cur_size) {
110 for (i = 0; i < af->nb_buffers; i++) {
111 if ((ret = av_fifo_grow2(af->buf[i], buf_size - cur_size)) < 0)
112 return ret;
113 }
114 }
115 af->allocated_samples = nb_samples;
116 return 0;
117 }
118
av_audio_fifo_write(AVAudioFifo * af,void ** data,int nb_samples)119 int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
120 {
121 int i, ret, size;
122
123 /* automatically reallocate buffers if needed */
124 if (av_audio_fifo_space(af) < nb_samples) {
125 int current_size = av_audio_fifo_size(af);
126 /* check for integer overflow in new size calculation */
127 if (INT_MAX / 2 - current_size < nb_samples)
128 return AVERROR(EINVAL);
129 /* reallocate buffers */
130 if ((ret = av_audio_fifo_realloc(af, 2 * (current_size + nb_samples))) < 0)
131 return ret;
132 }
133
134 size = nb_samples * af->sample_size;
135 for (i = 0; i < af->nb_buffers; i++) {
136 ret = av_fifo_write(af->buf[i], data[i], size);
137 if (ret < 0)
138 return AVERROR_BUG;
139 }
140 af->nb_samples += nb_samples;
141
142 return nb_samples;
143 }
144
av_audio_fifo_peek(AVAudioFifo * af,void ** data,int nb_samples)145 int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
146 {
147 return av_audio_fifo_peek_at(af, data, nb_samples, 0);
148 }
149
av_audio_fifo_peek_at(AVAudioFifo * af,void ** data,int nb_samples,int offset)150 int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset)
151 {
152 int i, ret, size;
153
154 if (offset < 0 || offset >= af->nb_samples)
155 return AVERROR(EINVAL);
156 if (nb_samples < 0)
157 return AVERROR(EINVAL);
158 nb_samples = FFMIN(nb_samples, af->nb_samples);
159 if (!nb_samples)
160 return 0;
161 if (offset > af->nb_samples - nb_samples)
162 return AVERROR(EINVAL);
163
164 offset *= af->sample_size;
165 size = nb_samples * af->sample_size;
166 for (i = 0; i < af->nb_buffers; i++) {
167 if ((ret = av_fifo_peek(af->buf[i], data[i], size, offset)) < 0)
168 return AVERROR_BUG;
169 }
170
171 return nb_samples;
172 }
173
av_audio_fifo_read(AVAudioFifo * af,void ** data,int nb_samples)174 int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
175 {
176 int i, size;
177
178 if (nb_samples < 0)
179 return AVERROR(EINVAL);
180 nb_samples = FFMIN(nb_samples, af->nb_samples);
181 if (!nb_samples)
182 return 0;
183
184 size = nb_samples * af->sample_size;
185 for (i = 0; i < af->nb_buffers; i++) {
186 if (av_fifo_read(af->buf[i], data[i], size) < 0)
187 return AVERROR_BUG;
188 }
189 af->nb_samples -= nb_samples;
190
191 return nb_samples;
192 }
193
av_audio_fifo_drain(AVAudioFifo * af,int nb_samples)194 int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
195 {
196 int i, size;
197
198 if (nb_samples < 0)
199 return AVERROR(EINVAL);
200 nb_samples = FFMIN(nb_samples, af->nb_samples);
201
202 if (nb_samples) {
203 size = nb_samples * af->sample_size;
204 for (i = 0; i < af->nb_buffers; i++)
205 av_fifo_drain2(af->buf[i], size);
206 af->nb_samples -= nb_samples;
207 }
208 return 0;
209 }
210
av_audio_fifo_reset(AVAudioFifo * af)211 void av_audio_fifo_reset(AVAudioFifo *af)
212 {
213 int i;
214
215 for (i = 0; i < af->nb_buffers; i++)
216 av_fifo_reset2(af->buf[i]);
217
218 af->nb_samples = 0;
219 }
220
av_audio_fifo_size(AVAudioFifo * af)221 int av_audio_fifo_size(AVAudioFifo *af)
222 {
223 return af->nb_samples;
224 }
225
av_audio_fifo_space(AVAudioFifo * af)226 int av_audio_fifo_space(AVAudioFifo *af)
227 {
228 return af->allocated_samples - af->nb_samples;
229 }
230