Line |
Branch |
Exec |
Source |
1 |
|
|
/* |
2 |
|
|
* Bonk audio decoder |
3 |
|
|
* |
4 |
|
|
* This file is part of FFmpeg. |
5 |
|
|
* |
6 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
7 |
|
|
* modify it under the terms of the GNU Lesser General Public |
8 |
|
|
* License as published by the Free Software Foundation; either |
9 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
10 |
|
|
* |
11 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
12 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 |
|
|
* Lesser General Public License for more details. |
15 |
|
|
* |
16 |
|
|
* You should have received a copy of the GNU Lesser General Public |
17 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
18 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
#include "libavutil/internal.h" |
22 |
|
|
#include "libavutil/intreadwrite.h" |
23 |
|
|
#include "avcodec.h" |
24 |
|
|
#include "codec_internal.h" |
25 |
|
|
#include "decode.h" |
26 |
|
|
#define BITSTREAM_READER_LE |
27 |
|
|
#include "get_bits.h" |
28 |
|
|
#include "bytestream.h" |
29 |
|
|
|
30 |
|
|
typedef struct BitCount { |
31 |
|
|
uint8_t bit; |
32 |
|
|
unsigned count; |
33 |
|
|
} BitCount; |
34 |
|
|
|
35 |
|
|
typedef struct BonkContext { |
36 |
|
|
GetBitContext gb; |
37 |
|
|
int skip; |
38 |
|
|
|
39 |
|
|
uint8_t *bitstream; |
40 |
|
|
int64_t max_framesize; |
41 |
|
|
int bitstream_size; |
42 |
|
|
int bitstream_index; |
43 |
|
|
|
44 |
|
|
uint64_t nb_samples; |
45 |
|
|
int lossless; |
46 |
|
|
int mid_side; |
47 |
|
|
int n_taps; |
48 |
|
|
int down_sampling; |
49 |
|
|
int samples_per_packet; |
50 |
|
|
|
51 |
|
|
int state[2][2048], k[2048]; |
52 |
|
|
int *samples[2]; |
53 |
|
|
int *input_samples; |
54 |
|
|
uint8_t quant[2048]; |
55 |
|
|
BitCount *bits; |
56 |
|
|
} BonkContext; |
57 |
|
|
|
58 |
|
✗ |
static av_cold int bonk_close(AVCodecContext *avctx) |
59 |
|
|
{ |
60 |
|
✗ |
BonkContext *s = avctx->priv_data; |
61 |
|
|
|
62 |
|
✗ |
av_freep(&s->bitstream); |
63 |
|
✗ |
av_freep(&s->input_samples); |
64 |
|
✗ |
av_freep(&s->samples[0]); |
65 |
|
✗ |
av_freep(&s->samples[1]); |
66 |
|
✗ |
av_freep(&s->bits); |
67 |
|
✗ |
s->bitstream_size = 0; |
68 |
|
|
|
69 |
|
✗ |
return 0; |
70 |
|
|
} |
71 |
|
|
|
72 |
|
✗ |
static av_cold int bonk_init(AVCodecContext *avctx) |
73 |
|
|
{ |
74 |
|
✗ |
BonkContext *s = avctx->priv_data; |
75 |
|
|
|
76 |
|
✗ |
avctx->sample_fmt = AV_SAMPLE_FMT_S16P; |
77 |
|
✗ |
if (avctx->extradata_size < 17) |
78 |
|
✗ |
return AVERROR(EINVAL); |
79 |
|
|
|
80 |
|
✗ |
if (avctx->extradata[0]) { |
81 |
|
✗ |
av_log(avctx, AV_LOG_ERROR, "Unsupported version.\n"); |
82 |
|
✗ |
return AVERROR_INVALIDDATA; |
83 |
|
|
} |
84 |
|
|
|
85 |
|
✗ |
if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2) |
86 |
|
✗ |
return AVERROR_INVALIDDATA; |
87 |
|
|
|
88 |
|
✗ |
s->nb_samples = AV_RL32(avctx->extradata + 1) / avctx->ch_layout.nb_channels; |
89 |
|
✗ |
if (!s->nb_samples) |
90 |
|
✗ |
s->nb_samples = UINT64_MAX; |
91 |
|
✗ |
s->lossless = avctx->extradata[10] != 0; |
92 |
|
✗ |
s->mid_side = avctx->extradata[11] != 0; |
93 |
|
✗ |
s->n_taps = AV_RL16(avctx->extradata + 12); |
94 |
|
✗ |
if (!s->n_taps || s->n_taps > 2048) |
95 |
|
✗ |
return AVERROR(EINVAL); |
96 |
|
|
|
97 |
|
✗ |
s->down_sampling = avctx->extradata[14]; |
98 |
|
✗ |
if (!s->down_sampling) |
99 |
|
✗ |
return AVERROR(EINVAL); |
100 |
|
|
|
101 |
|
✗ |
s->samples_per_packet = AV_RL16(avctx->extradata + 15); |
102 |
|
✗ |
if (!s->samples_per_packet) |
103 |
|
✗ |
return AVERROR(EINVAL); |
104 |
|
|
|
105 |
|
✗ |
if (s->down_sampling * s->samples_per_packet < s->n_taps) |
106 |
|
✗ |
return AVERROR_INVALIDDATA; |
107 |
|
|
|
108 |
|
✗ |
s->max_framesize = s->samples_per_packet * avctx->ch_layout.nb_channels * s->down_sampling * 16LL; |
109 |
|
✗ |
if (s->max_framesize > (INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 8) |
110 |
|
✗ |
return AVERROR_INVALIDDATA; |
111 |
|
|
|
112 |
|
✗ |
s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE, sizeof(*s->bitstream)); |
113 |
|
✗ |
if (!s->bitstream) |
114 |
|
✗ |
return AVERROR(ENOMEM); |
115 |
|
|
|
116 |
|
✗ |
s->input_samples = av_calloc(s->samples_per_packet, sizeof(*s->input_samples)); |
117 |
|
✗ |
if (!s->input_samples) |
118 |
|
✗ |
return AVERROR(ENOMEM); |
119 |
|
|
|
120 |
|
✗ |
s->samples[0] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0])); |
121 |
|
✗ |
s->samples[1] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0])); |
122 |
|
✗ |
if (!s->samples[0] || !s->samples[1]) |
123 |
|
✗ |
return AVERROR(ENOMEM); |
124 |
|
|
|
125 |
|
✗ |
s->bits = av_calloc(s->max_framesize * 8, sizeof(*s->bits)); |
126 |
|
✗ |
if (!s->bits) |
127 |
|
✗ |
return AVERROR(ENOMEM); |
128 |
|
|
|
129 |
|
✗ |
for (int i = 0; i < 512; i++) { |
130 |
|
✗ |
s->quant[i] = sqrt(i + 1); |
131 |
|
|
} |
132 |
|
|
|
133 |
|
✗ |
return 0; |
134 |
|
|
} |
135 |
|
|
|
136 |
|
✗ |
static unsigned read_uint_max(BonkContext *s, uint32_t max) |
137 |
|
|
{ |
138 |
|
✗ |
unsigned value = 0; |
139 |
|
|
|
140 |
|
✗ |
if (max == 0) |
141 |
|
✗ |
return 0; |
142 |
|
|
|
143 |
|
✗ |
av_assert0(max >> 31 == 0); |
144 |
|
|
|
145 |
|
✗ |
for (unsigned i = 1; i <= max - value; i+=i) |
146 |
|
✗ |
if (get_bits1(&s->gb)) |
147 |
|
✗ |
value += i; |
148 |
|
|
|
149 |
|
✗ |
return value; |
150 |
|
|
} |
151 |
|
|
|
152 |
|
✗ |
static int intlist_read(BonkContext *s, int *buf, int entries, int base_2_part) |
153 |
|
|
{ |
154 |
|
✗ |
int i, low_bits = 0, x = 0, max_x; |
155 |
|
✗ |
int n_zeros = 0, step = 256, dominant = 0; |
156 |
|
✗ |
int pos = 0, level = 0; |
157 |
|
✗ |
BitCount *bits = s->bits; |
158 |
|
✗ |
int passes = 1; |
159 |
|
|
|
160 |
|
✗ |
memset(buf, 0, entries * sizeof(*buf)); |
161 |
|
✗ |
if (base_2_part) { |
162 |
|
✗ |
low_bits = get_bits(&s->gb, 4); |
163 |
|
|
|
164 |
|
✗ |
if (low_bits) |
165 |
|
✗ |
for (i = 0; i < entries; i++) |
166 |
|
✗ |
buf[i] = get_bits(&s->gb, low_bits); |
167 |
|
|
} |
168 |
|
|
|
169 |
|
✗ |
while (n_zeros < entries) { |
170 |
|
✗ |
int steplet = step >> 8; |
171 |
|
|
|
172 |
|
✗ |
if (get_bits_left(&s->gb) <= 0) |
173 |
|
✗ |
return AVERROR_INVALIDDATA; |
174 |
|
|
|
175 |
|
✗ |
if (!get_bits1(&s->gb)) { |
176 |
|
✗ |
av_assert0(steplet >= 0); |
177 |
|
|
|
178 |
|
✗ |
if (steplet > 0) { |
179 |
|
✗ |
bits[x ].bit = dominant; |
180 |
|
✗ |
bits[x++].count = steplet; |
181 |
|
|
} |
182 |
|
|
|
183 |
|
✗ |
if (!dominant) |
184 |
|
✗ |
n_zeros += steplet; |
185 |
|
|
|
186 |
|
✗ |
if (step > INT32_MAX*8LL/9 + 1) |
187 |
|
✗ |
return AVERROR_INVALIDDATA; |
188 |
|
✗ |
step += step / 8; |
189 |
|
✗ |
} else if (steplet > 0) { |
190 |
|
✗ |
int actual_run = read_uint_max(s, steplet - 1); |
191 |
|
|
|
192 |
|
✗ |
av_assert0(actual_run >= 0); |
193 |
|
|
|
194 |
|
✗ |
if (actual_run > 0) { |
195 |
|
✗ |
bits[x ].bit = dominant; |
196 |
|
✗ |
bits[x++].count = actual_run; |
197 |
|
|
} |
198 |
|
|
|
199 |
|
✗ |
bits[x ].bit = !dominant; |
200 |
|
✗ |
bits[x++].count = 1; |
201 |
|
|
|
202 |
|
✗ |
if (!dominant) |
203 |
|
✗ |
n_zeros += actual_run; |
204 |
|
|
else |
205 |
|
✗ |
n_zeros++; |
206 |
|
|
|
207 |
|
✗ |
step -= step / 8; |
208 |
|
|
} |
209 |
|
|
|
210 |
|
✗ |
if (step < 256) { |
211 |
|
✗ |
step = 65536 / step; |
212 |
|
✗ |
dominant = !dominant; |
213 |
|
|
} |
214 |
|
|
} |
215 |
|
|
|
216 |
|
✗ |
max_x = x; |
217 |
|
✗ |
x = 0; |
218 |
|
✗ |
n_zeros = 0; |
219 |
|
✗ |
for (i = 0; n_zeros < entries; i++) { |
220 |
|
✗ |
if (x >= max_x) |
221 |
|
✗ |
return AVERROR_INVALIDDATA; |
222 |
|
|
|
223 |
|
✗ |
if (pos >= entries) { |
224 |
|
✗ |
pos = 0; |
225 |
|
✗ |
level += passes << low_bits; |
226 |
|
✗ |
passes = 1; |
227 |
|
✗ |
if (bits[x].bit && bits[x].count > entries - n_zeros) |
228 |
|
✗ |
passes = bits[x].count / (entries - n_zeros); |
229 |
|
|
} |
230 |
|
|
|
231 |
|
✗ |
if (level > 1 << 16) |
232 |
|
✗ |
return AVERROR_INVALIDDATA; |
233 |
|
|
|
234 |
|
✗ |
if (buf[pos] >= level) { |
235 |
|
✗ |
if (bits[x].bit) |
236 |
|
✗ |
buf[pos] += passes << low_bits; |
237 |
|
|
else |
238 |
|
✗ |
n_zeros++; |
239 |
|
|
|
240 |
|
|
av_assert1(bits[x].count >= passes); |
241 |
|
✗ |
bits[x].count -= passes; |
242 |
|
✗ |
x += bits[x].count == 0; |
243 |
|
|
} |
244 |
|
|
|
245 |
|
✗ |
pos++; |
246 |
|
|
} |
247 |
|
|
|
248 |
|
✗ |
for (i = 0; i < entries; i++) { |
249 |
|
✗ |
if (buf[i] && get_bits1(&s->gb)) { |
250 |
|
✗ |
buf[i] = -buf[i]; |
251 |
|
|
} |
252 |
|
|
} |
253 |
|
|
|
254 |
|
✗ |
return 0; |
255 |
|
|
} |
256 |
|
|
|
257 |
|
✗ |
static inline int shift_down(int a, int b) |
258 |
|
|
{ |
259 |
|
✗ |
return (a >> b) + (a < 0); |
260 |
|
|
} |
261 |
|
|
|
262 |
|
✗ |
static inline int shift(int a, int b) |
263 |
|
|
{ |
264 |
|
✗ |
return a + (1 << b - 1) >> b; |
265 |
|
|
} |
266 |
|
|
|
267 |
|
|
#define LATTICE_SHIFT 10 |
268 |
|
|
#define SAMPLE_SHIFT 4 |
269 |
|
|
#define SAMPLE_FACTOR (1 << SAMPLE_SHIFT) |
270 |
|
|
|
271 |
|
✗ |
static int predictor_calc_error(int *k, int *state, int order, int error) |
272 |
|
|
{ |
273 |
|
✗ |
int i, x = error - (unsigned)shift_down(k[order-1] * (unsigned)state[order-1], LATTICE_SHIFT); |
274 |
|
✗ |
int *k_ptr = &(k[order-2]), |
275 |
|
✗ |
*state_ptr = &(state[order-2]); |
276 |
|
|
|
277 |
|
✗ |
for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--) { |
278 |
|
✗ |
unsigned k_value = *k_ptr, state_value = *state_ptr; |
279 |
|
|
|
280 |
|
✗ |
x -= (unsigned) shift_down(k_value * (unsigned)state_value, LATTICE_SHIFT); |
281 |
|
✗ |
state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT); |
282 |
|
|
} |
283 |
|
|
|
284 |
|
|
// don't drift too far, to avoid overflows |
285 |
|
✗ |
x = av_clip(x, -(SAMPLE_FACTOR << 16), SAMPLE_FACTOR << 16); |
286 |
|
|
|
287 |
|
✗ |
state[0] = x; |
288 |
|
|
|
289 |
|
✗ |
return x; |
290 |
|
|
} |
291 |
|
|
|
292 |
|
✗ |
static void predictor_init_state(int *k, unsigned *state, int order) |
293 |
|
|
{ |
294 |
|
✗ |
for (int i = order - 2; i >= 0; i--) { |
295 |
|
✗ |
unsigned x = state[i]; |
296 |
|
|
|
297 |
|
✗ |
for (int j = 0, p = i + 1; p < order; j++, p++) { |
298 |
|
✗ |
int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT); |
299 |
|
|
|
300 |
|
✗ |
state[p] += shift_down(k[j] * x, LATTICE_SHIFT); |
301 |
|
✗ |
x = tmp; |
302 |
|
|
} |
303 |
|
|
} |
304 |
|
✗ |
} |
305 |
|
|
|
306 |
|
✗ |
static int bonk_decode(AVCodecContext *avctx, AVFrame *frame, |
307 |
|
|
int *got_frame_ptr, AVPacket *pkt) |
308 |
|
|
{ |
309 |
|
✗ |
BonkContext *s = avctx->priv_data; |
310 |
|
✗ |
GetBitContext *gb = &s->gb; |
311 |
|
|
const uint8_t *buf; |
312 |
|
|
int quant, n, buf_size, input_buf_size; |
313 |
|
✗ |
int ret = AVERROR_INVALIDDATA; |
314 |
|
|
|
315 |
|
✗ |
if ((!pkt->size && !s->bitstream_size) || s->nb_samples == 0) { |
316 |
|
✗ |
*got_frame_ptr = 0; |
317 |
|
✗ |
return pkt->size; |
318 |
|
|
} |
319 |
|
|
|
320 |
|
✗ |
buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size); |
321 |
|
✗ |
input_buf_size = buf_size; |
322 |
|
✗ |
if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE > s->max_framesize) { |
323 |
|
✗ |
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); |
324 |
|
✗ |
s->bitstream_index = 0; |
325 |
|
|
} |
326 |
|
✗ |
if (pkt->data) |
327 |
|
✗ |
memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size); |
328 |
|
✗ |
buf = &s->bitstream[s->bitstream_index]; |
329 |
|
✗ |
buf_size += s->bitstream_size; |
330 |
|
✗ |
s->bitstream_size = buf_size; |
331 |
|
✗ |
if (buf_size < s->max_framesize && pkt->data) { |
332 |
|
✗ |
*got_frame_ptr = 0; |
333 |
|
✗ |
return input_buf_size; |
334 |
|
|
} |
335 |
|
|
|
336 |
|
✗ |
frame->nb_samples = FFMIN(s->samples_per_packet * s->down_sampling, s->nb_samples); |
337 |
|
✗ |
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
338 |
|
✗ |
goto fail; |
339 |
|
|
|
340 |
|
✗ |
if ((ret = init_get_bits8(gb, buf, buf_size)) < 0) |
341 |
|
✗ |
goto fail; |
342 |
|
|
|
343 |
|
✗ |
skip_bits(gb, s->skip); |
344 |
|
✗ |
if ((ret = intlist_read(s, s->k, s->n_taps, 0)) < 0) |
345 |
|
✗ |
goto fail; |
346 |
|
|
|
347 |
|
✗ |
for (int i = 0; i < s->n_taps; i++) |
348 |
|
✗ |
s->k[i] *= s->quant[i]; |
349 |
|
✗ |
quant = s->lossless ? 1 : get_bits(&s->gb, 16) * SAMPLE_FACTOR; |
350 |
|
|
|
351 |
|
✗ |
for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
352 |
|
✗ |
const int samples_per_packet = s->samples_per_packet; |
353 |
|
✗ |
const int down_sampling = s->down_sampling; |
354 |
|
✗ |
const int offset = samples_per_packet * down_sampling - 1; |
355 |
|
✗ |
int *state = s->state[ch]; |
356 |
|
✗ |
int *sample = s->samples[ch]; |
357 |
|
|
|
358 |
|
✗ |
predictor_init_state(s->k, state, s->n_taps); |
359 |
|
✗ |
if ((ret = intlist_read(s, s->input_samples, samples_per_packet, 1)) < 0) |
360 |
|
✗ |
goto fail; |
361 |
|
|
|
362 |
|
✗ |
for (int i = 0; i < samples_per_packet; i++) { |
363 |
|
✗ |
for (int j = 0; j < s->down_sampling - 1; j++) { |
364 |
|
✗ |
sample[0] = predictor_calc_error(s->k, state, s->n_taps, 0); |
365 |
|
✗ |
sample++; |
366 |
|
|
} |
367 |
|
|
|
368 |
|
✗ |
sample[0] = predictor_calc_error(s->k, state, s->n_taps, s->input_samples[i] * (unsigned)quant); |
369 |
|
✗ |
sample++; |
370 |
|
|
} |
371 |
|
|
|
372 |
|
✗ |
sample = s->samples[ch]; |
373 |
|
✗ |
for (int i = 0; i < s->n_taps; i++) |
374 |
|
✗ |
state[i] = sample[offset - i]; |
375 |
|
|
} |
376 |
|
|
|
377 |
|
✗ |
if (s->mid_side && avctx->ch_layout.nb_channels == 2) { |
378 |
|
✗ |
for (int i = 0; i < frame->nb_samples; i++) { |
379 |
|
✗ |
s->samples[1][i] += shift(s->samples[0][i], 1); |
380 |
|
✗ |
s->samples[0][i] -= s->samples[1][i]; |
381 |
|
|
} |
382 |
|
|
} |
383 |
|
|
|
384 |
|
✗ |
if (!s->lossless) { |
385 |
|
✗ |
for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
386 |
|
✗ |
int *samples = s->samples[ch]; |
387 |
|
✗ |
for (int i = 0; i < frame->nb_samples; i++) |
388 |
|
✗ |
samples[i] = shift(samples[i], 4); |
389 |
|
|
} |
390 |
|
|
} |
391 |
|
|
|
392 |
|
✗ |
for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
393 |
|
✗ |
int16_t *osamples = (int16_t *)frame->extended_data[ch]; |
394 |
|
✗ |
int *samples = s->samples[ch]; |
395 |
|
✗ |
for (int i = 0; i < frame->nb_samples; i++) |
396 |
|
✗ |
osamples[i] = av_clip_int16(samples[i]); |
397 |
|
|
} |
398 |
|
|
|
399 |
|
✗ |
s->nb_samples -= frame->nb_samples; |
400 |
|
|
|
401 |
|
✗ |
s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8); |
402 |
|
✗ |
n = get_bits_count(gb) / 8; |
403 |
|
|
|
404 |
|
✗ |
if (n > buf_size) { |
405 |
|
✗ |
fail: |
406 |
|
✗ |
s->bitstream_size = 0; |
407 |
|
✗ |
s->bitstream_index = 0; |
408 |
|
✗ |
return AVERROR_INVALIDDATA; |
409 |
|
|
} |
410 |
|
|
|
411 |
|
✗ |
*got_frame_ptr = 1; |
412 |
|
|
|
413 |
|
✗ |
if (s->bitstream_size) { |
414 |
|
✗ |
s->bitstream_index += n; |
415 |
|
✗ |
s->bitstream_size -= n; |
416 |
|
✗ |
return input_buf_size; |
417 |
|
|
} |
418 |
|
✗ |
return n; |
419 |
|
|
} |
420 |
|
|
|
421 |
|
|
const FFCodec ff_bonk_decoder = { |
422 |
|
|
.p.name = "bonk", |
423 |
|
|
CODEC_LONG_NAME("Bonk audio"), |
424 |
|
|
.p.type = AVMEDIA_TYPE_AUDIO, |
425 |
|
|
.p.id = AV_CODEC_ID_BONK, |
426 |
|
|
.priv_data_size = sizeof(BonkContext), |
427 |
|
|
.init = bonk_init, |
428 |
|
|
FF_CODEC_DECODE_CB(bonk_decode), |
429 |
|
|
.close = bonk_close, |
430 |
|
|
.p.capabilities = AV_CODEC_CAP_DELAY | |
431 |
|
|
#if FF_API_SUBFRAMES |
432 |
|
|
AV_CODEC_CAP_SUBFRAMES | |
433 |
|
|
#endif |
434 |
|
|
AV_CODEC_CAP_DR1, |
435 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
436 |
|
|
.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, |
437 |
|
|
AV_SAMPLE_FMT_NONE }, |
438 |
|
|
}; |
439 |
|
|
|