1
by Sérgio Benjamim
FFmpeg 2.7.1 source for ppsspp. |
1 |
/*
|
2 |
* copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
|
|
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 |
/**
|
|
22 |
* @file
|
|
23 |
* Native Vorbis encoder.
|
|
24 |
* @author Oded Shimon <ods15@ods15.dyndns.org>
|
|
25 |
*/
|
|
26 |
||
27 |
#include <float.h> |
|
28 |
||
29 |
#include "avcodec.h" |
|
30 |
#include "internal.h" |
|
31 |
#include "fft.h" |
|
32 |
#include "mathops.h" |
|
33 |
#include "vorbis.h" |
|
34 |
#include "vorbis_enc_data.h" |
|
35 |
||
36 |
#define BITSTREAM_WRITER_LE
|
|
37 |
#include "put_bits.h" |
|
38 |
||
39 |
#undef NDEBUG
|
|
40 |
#include <assert.h> |
|
41 |
||
42 |
typedef struct vorbis_enc_codebook { |
|
43 |
int nentries; |
|
44 |
uint8_t *lens; |
|
45 |
uint32_t *codewords; |
|
46 |
int ndimensions; |
|
47 |
float min; |
|
48 |
float delta; |
|
49 |
int seq_p; |
|
50 |
int lookup; |
|
51 |
int *quantlist; |
|
52 |
float *dimensions; |
|
53 |
float *pow2; |
|
54 |
} vorbis_enc_codebook; |
|
55 |
||
56 |
typedef struct vorbis_enc_floor_class { |
|
57 |
int dim; |
|
58 |
int subclass; |
|
59 |
int masterbook; |
|
60 |
int *books; |
|
61 |
} vorbis_enc_floor_class; |
|
62 |
||
63 |
typedef struct vorbis_enc_floor { |
|
64 |
int partitions; |
|
65 |
int *partition_to_class; |
|
66 |
int nclasses; |
|
67 |
vorbis_enc_floor_class *classes; |
|
68 |
int multiplier; |
|
69 |
int rangebits; |
|
70 |
int values; |
|
71 |
vorbis_floor1_entry *list; |
|
72 |
} vorbis_enc_floor; |
|
73 |
||
74 |
typedef struct vorbis_enc_residue { |
|
75 |
int type; |
|
76 |
int begin; |
|
77 |
int end; |
|
78 |
int partition_size; |
|
79 |
int classifications; |
|
80 |
int classbook; |
|
81 |
int8_t (*books)[8]; |
|
82 |
float (*maxes)[2]; |
|
83 |
} vorbis_enc_residue; |
|
84 |
||
85 |
typedef struct vorbis_enc_mapping { |
|
86 |
int submaps; |
|
87 |
int *mux; |
|
88 |
int *floor; |
|
89 |
int *residue; |
|
90 |
int coupling_steps; |
|
91 |
int *magnitude; |
|
92 |
int *angle; |
|
93 |
} vorbis_enc_mapping; |
|
94 |
||
95 |
typedef struct vorbis_enc_mode { |
|
96 |
int blockflag; |
|
97 |
int mapping; |
|
98 |
} vorbis_enc_mode; |
|
99 |
||
100 |
typedef struct vorbis_enc_context { |
|
101 |
int channels; |
|
102 |
int sample_rate; |
|
103 |
int log2_blocksize[2]; |
|
104 |
FFTContext mdct[2]; |
|
105 |
const float *win[2]; |
|
106 |
int have_saved; |
|
107 |
float *saved; |
|
108 |
float *samples; |
|
109 |
float *floor; // also used for tmp values for mdct |
|
110 |
float *coeffs; // also used for residue after floor |
|
111 |
float quality; |
|
112 |
||
113 |
int ncodebooks; |
|
114 |
vorbis_enc_codebook *codebooks; |
|
115 |
||
116 |
int nfloors; |
|
117 |
vorbis_enc_floor *floors; |
|
118 |
||
119 |
int nresidues; |
|
120 |
vorbis_enc_residue *residues; |
|
121 |
||
122 |
int nmappings; |
|
123 |
vorbis_enc_mapping *mappings; |
|
124 |
||
125 |
int nmodes; |
|
126 |
vorbis_enc_mode *modes; |
|
127 |
||
128 |
int64_t next_pts; |
|
129 |
} vorbis_enc_context; |
|
130 |
||
131 |
#define MAX_CHANNELS 2
|
|
132 |
#define MAX_CODEBOOK_DIM 8
|
|
133 |
||
134 |
#define MAX_FLOOR_CLASS_DIM 4
|
|
135 |
#define NUM_FLOOR_PARTITIONS 8
|
|
136 |
#define MAX_FLOOR_VALUES (MAX_FLOOR_CLASS_DIM*NUM_FLOOR_PARTITIONS+2)
|
|
137 |
||
138 |
#define RESIDUE_SIZE 1600
|
|
139 |
#define RESIDUE_PART_SIZE 32
|
|
140 |
#define NUM_RESIDUE_PARTITIONS (RESIDUE_SIZE/RESIDUE_PART_SIZE)
|
|
141 |
||
142 |
static inline int put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb, |
|
143 |
int entry) |
|
144 |
{
|
|
145 |
av_assert2(entry >= 0); |
|
146 |
av_assert2(entry < cb->nentries); |
|
147 |
av_assert2(cb->lens[entry]); |
|
148 |
if (pb->size_in_bits - put_bits_count(pb) < cb->lens[entry]) |
|
149 |
return AVERROR(EINVAL); |
|
150 |
put_bits(pb, cb->lens[entry], cb->codewords[entry]); |
|
151 |
return 0; |
|
152 |
}
|
|
153 |
||
154 |
static int cb_lookup_vals(int lookup, int dimensions, int entries) |
|
155 |
{
|
|
156 |
if (lookup == 1) |
|
157 |
return ff_vorbis_nth_root(entries, dimensions); |
|
158 |
else if (lookup == 2) |
|
159 |
return dimensions *entries; |
|
160 |
return 0; |
|
161 |
}
|
|
162 |
||
163 |
static int ready_codebook(vorbis_enc_codebook *cb) |
|
164 |
{
|
|
165 |
int i; |
|
166 |
||
167 |
ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries); |
|
168 |
||
169 |
if (!cb->lookup) { |
|
170 |
cb->pow2 = cb->dimensions = NULL; |
|
171 |
} else { |
|
172 |
int vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); |
|
173 |
cb->dimensions = av_malloc_array(cb->nentries, sizeof(float) * cb->ndimensions); |
|
174 |
cb->pow2 = av_mallocz_array(cb->nentries, sizeof(float)); |
|
175 |
if (!cb->dimensions || !cb->pow2) |
|
176 |
return AVERROR(ENOMEM); |
|
177 |
for (i = 0; i < cb->nentries; i++) { |
|
178 |
float last = 0; |
|
179 |
int j; |
|
180 |
int div = 1; |
|
181 |
for (j = 0; j < cb->ndimensions; j++) { |
|
182 |
int off; |
|
183 |
if (cb->lookup == 1) |
|
184 |
off = (i / div) % vals; // lookup type 1 |
|
185 |
else
|
|
186 |
off = i * cb->ndimensions + j; // lookup type 2 |
|
187 |
||
188 |
cb->dimensions[i * cb->ndimensions + j] = last + cb->min + cb->quantlist[off] * cb->delta; |
|
189 |
if (cb->seq_p) |
|
190 |
last = cb->dimensions[i * cb->ndimensions + j]; |
|
191 |
cb->pow2[i] += cb->dimensions[i * cb->ndimensions + j] * cb->dimensions[i * cb->ndimensions + j]; |
|
192 |
div *= vals; |
|
193 |
}
|
|
194 |
cb->pow2[i] /= 2.0; |
|
195 |
}
|
|
196 |
}
|
|
197 |
return 0; |
|
198 |
}
|
|
199 |
||
200 |
static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc) |
|
201 |
{
|
|
202 |
int i; |
|
203 |
av_assert0(rc->type == 2); |
|
204 |
rc->maxes = av_mallocz_array(rc->classifications, sizeof(float[2])); |
|
205 |
if (!rc->maxes) |
|
206 |
return AVERROR(ENOMEM); |
|
207 |
for (i = 0; i < rc->classifications; i++) { |
|
208 |
int j; |
|
209 |
vorbis_enc_codebook * cb; |
|
210 |
for (j = 0; j < 8; j++) |
|
211 |
if (rc->books[i][j] != -1) |
|
212 |
break; |
|
213 |
if (j == 8) // zero |
|
214 |
continue; |
|
215 |
cb = &venc->codebooks[rc->books[i][j]]; |
|
216 |
assert(cb->ndimensions >= 2); |
|
217 |
assert(cb->lookup); |
|
218 |
||
219 |
for (j = 0; j < cb->nentries; j++) { |
|
220 |
float a; |
|
221 |
if (!cb->lens[j]) |
|
222 |
continue; |
|
223 |
a = fabs(cb->dimensions[j * cb->ndimensions]); |
|
224 |
if (a > rc->maxes[i][0]) |
|
225 |
rc->maxes[i][0] = a; |
|
226 |
a = fabs(cb->dimensions[j * cb->ndimensions + 1]); |
|
227 |
if (a > rc->maxes[i][1]) |
|
228 |
rc->maxes[i][1] = a; |
|
229 |
}
|
|
230 |
}
|
|
231 |
// small bias
|
|
232 |
for (i = 0; i < rc->classifications; i++) { |
|
233 |
rc->maxes[i][0] += 0.8; |
|
234 |
rc->maxes[i][1] += 0.8; |
|
235 |
}
|
|
236 |
return 0; |
|
237 |
}
|
|
238 |
||
239 |
static int create_vorbis_context(vorbis_enc_context *venc, |
|
240 |
AVCodecContext *avctx) |
|
241 |
{
|
|
242 |
vorbis_enc_floor *fc; |
|
243 |
vorbis_enc_residue *rc; |
|
244 |
vorbis_enc_mapping *mc; |
|
245 |
int i, book, ret; |
|
246 |
||
247 |
venc->channels = avctx->channels; |
|
248 |
venc->sample_rate = avctx->sample_rate; |
|
249 |
venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11; |
|
250 |
||
251 |
venc->ncodebooks = FF_ARRAY_ELEMS(cvectors); |
|
252 |
venc->codebooks = av_malloc(sizeof(vorbis_enc_codebook) * venc->ncodebooks); |
|
253 |
if (!venc->codebooks) |
|
254 |
return AVERROR(ENOMEM); |
|
255 |
||
256 |
// codebook 0..14 - floor1 book, values 0..255
|
|
257 |
// codebook 15 residue masterbook
|
|
258 |
// codebook 16..29 residue
|
|
259 |
for (book = 0; book < venc->ncodebooks; book++) { |
|
260 |
vorbis_enc_codebook *cb = &venc->codebooks[book]; |
|
261 |
int vals; |
|
262 |
cb->ndimensions = cvectors[book].dim; |
|
263 |
cb->nentries = cvectors[book].real_len; |
|
264 |
cb->min = cvectors[book].min; |
|
265 |
cb->delta = cvectors[book].delta; |
|
266 |
cb->lookup = cvectors[book].lookup; |
|
267 |
cb->seq_p = 0; |
|
268 |
||
269 |
cb->lens = av_malloc_array(cb->nentries, sizeof(uint8_t)); |
|
270 |
cb->codewords = av_malloc_array(cb->nentries, sizeof(uint32_t)); |
|
271 |
if (!cb->lens || !cb->codewords) |
|
272 |
return AVERROR(ENOMEM); |
|
273 |
memcpy(cb->lens, cvectors[book].clens, cvectors[book].len); |
|
274 |
memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len); |
|
275 |
||
276 |
if (cb->lookup) { |
|
277 |
vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); |
|
278 |
cb->quantlist = av_malloc_array(vals, sizeof(int)); |
|
279 |
if (!cb->quantlist) |
|
280 |
return AVERROR(ENOMEM); |
|
281 |
for (i = 0; i < vals; i++) |
|
282 |
cb->quantlist[i] = cvectors[book].quant[i]; |
|
283 |
} else { |
|
284 |
cb->quantlist = NULL; |
|
285 |
}
|
|
286 |
if ((ret = ready_codebook(cb)) < 0) |
|
287 |
return ret; |
|
288 |
}
|
|
289 |
||
290 |
venc->nfloors = 1; |
|
291 |
venc->floors = av_malloc(sizeof(vorbis_enc_floor) * venc->nfloors); |
|
292 |
if (!venc->floors) |
|
293 |
return AVERROR(ENOMEM); |
|
294 |
||
295 |
// just 1 floor
|
|
296 |
fc = &venc->floors[0]; |
|
297 |
fc->partitions = NUM_FLOOR_PARTITIONS; |
|
298 |
fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions); |
|
299 |
if (!fc->partition_to_class) |
|
300 |
return AVERROR(ENOMEM); |
|
301 |
fc->nclasses = 0; |
|
302 |
for (i = 0; i < fc->partitions; i++) { |
|
303 |
static const int a[] = {0, 1, 2, 2, 3, 3, 4, 4}; |
|
304 |
fc->partition_to_class[i] = a[i]; |
|
305 |
fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]); |
|
306 |
}
|
|
307 |
fc->nclasses++; |
|
308 |
fc->classes = av_malloc_array(fc->nclasses, sizeof(vorbis_enc_floor_class)); |
|
309 |
if (!fc->classes) |
|
310 |
return AVERROR(ENOMEM); |
|
311 |
for (i = 0; i < fc->nclasses; i++) { |
|
312 |
vorbis_enc_floor_class * c = &fc->classes[i]; |
|
313 |
int j, books; |
|
314 |
c->dim = floor_classes[i].dim; |
|
315 |
c->subclass = floor_classes[i].subclass; |
|
316 |
c->masterbook = floor_classes[i].masterbook; |
|
317 |
books = (1 << c->subclass); |
|
318 |
c->books = av_malloc_array(books, sizeof(int)); |
|
319 |
if (!c->books) |
|
320 |
return AVERROR(ENOMEM); |
|
321 |
for (j = 0; j < books; j++) |
|
322 |
c->books[j] = floor_classes[i].nbooks[j]; |
|
323 |
}
|
|
324 |
fc->multiplier = 2; |
|
325 |
fc->rangebits = venc->log2_blocksize[0] - 1; |
|
326 |
||
327 |
fc->values = 2; |
|
328 |
for (i = 0; i < fc->partitions; i++) |
|
329 |
fc->values += fc->classes[fc->partition_to_class[i]].dim; |
|
330 |
||
331 |
fc->list = av_malloc_array(fc->values, sizeof(vorbis_floor1_entry)); |
|
332 |
if (!fc->list) |
|
333 |
return AVERROR(ENOMEM); |
|
334 |
fc->list[0].x = 0; |
|
335 |
fc->list[1].x = 1 << fc->rangebits; |
|
336 |
for (i = 2; i < fc->values; i++) { |
|
337 |
static const int a[] = { |
|
338 |
93, 23,372, 6, 46,186,750, 14, 33, 65, |
|
339 |
130,260,556, 3, 10, 18, 28, 39, 55, 79, |
|
340 |
111,158,220,312,464,650,850 |
|
341 |
};
|
|
342 |
fc->list[i].x = a[i - 2]; |
|
343 |
}
|
|
344 |
if (ff_vorbis_ready_floor1_list(avctx, fc->list, fc->values)) |
|
345 |
return AVERROR_BUG; |
|
346 |
||
347 |
venc->nresidues = 1; |
|
348 |
venc->residues = av_malloc(sizeof(vorbis_enc_residue) * venc->nresidues); |
|
349 |
if (!venc->residues) |
|
350 |
return AVERROR(ENOMEM); |
|
351 |
||
352 |
// single residue
|
|
353 |
rc = &venc->residues[0]; |
|
354 |
rc->type = 2; |
|
355 |
rc->begin = 0; |
|
356 |
rc->end = 1600; |
|
357 |
rc->partition_size = 32; |
|
358 |
rc->classifications = 10; |
|
359 |
rc->classbook = 15; |
|
360 |
rc->books = av_malloc(sizeof(*rc->books) * rc->classifications); |
|
361 |
if (!rc->books) |
|
362 |
return AVERROR(ENOMEM); |
|
363 |
{
|
|
364 |
static const int8_t a[10][8] = { |
|
365 |
{ -1, -1, -1, -1, -1, -1, -1, -1, }, |
|
366 |
{ -1, -1, 16, -1, -1, -1, -1, -1, }, |
|
367 |
{ -1, -1, 17, -1, -1, -1, -1, -1, }, |
|
368 |
{ -1, -1, 18, -1, -1, -1, -1, -1, }, |
|
369 |
{ -1, -1, 19, -1, -1, -1, -1, -1, }, |
|
370 |
{ -1, -1, 20, -1, -1, -1, -1, -1, }, |
|
371 |
{ -1, -1, 21, -1, -1, -1, -1, -1, }, |
|
372 |
{ 22, 23, -1, -1, -1, -1, -1, -1, }, |
|
373 |
{ 24, 25, -1, -1, -1, -1, -1, -1, }, |
|
374 |
{ 26, 27, 28, -1, -1, -1, -1, -1, }, |
|
375 |
};
|
|
376 |
memcpy(rc->books, a, sizeof a); |
|
377 |
}
|
|
378 |
if ((ret = ready_residue(rc, venc)) < 0) |
|
379 |
return ret; |
|
380 |
||
381 |
venc->nmappings = 1; |
|
382 |
venc->mappings = av_malloc(sizeof(vorbis_enc_mapping) * venc->nmappings); |
|
383 |
if (!venc->mappings) |
|
384 |
return AVERROR(ENOMEM); |
|
385 |
||
386 |
// single mapping
|
|
387 |
mc = &venc->mappings[0]; |
|
388 |
mc->submaps = 1; |
|
389 |
mc->mux = av_malloc(sizeof(int) * venc->channels); |
|
390 |
if (!mc->mux) |
|
391 |
return AVERROR(ENOMEM); |
|
392 |
for (i = 0; i < venc->channels; i++) |
|
393 |
mc->mux[i] = 0; |
|
394 |
mc->floor = av_malloc(sizeof(int) * mc->submaps); |
|
395 |
mc->residue = av_malloc(sizeof(int) * mc->submaps); |
|
396 |
if (!mc->floor || !mc->residue) |
|
397 |
return AVERROR(ENOMEM); |
|
398 |
for (i = 0; i < mc->submaps; i++) { |
|
399 |
mc->floor[i] = 0; |
|
400 |
mc->residue[i] = 0; |
|
401 |
}
|
|
402 |
mc->coupling_steps = venc->channels == 2 ? 1 : 0; |
|
403 |
mc->magnitude = av_malloc(sizeof(int) * mc->coupling_steps); |
|
404 |
mc->angle = av_malloc(sizeof(int) * mc->coupling_steps); |
|
405 |
if (!mc->magnitude || !mc->angle) |
|
406 |
return AVERROR(ENOMEM); |
|
407 |
if (mc->coupling_steps) { |
|
408 |
mc->magnitude[0] = 0; |
|
409 |
mc->angle[0] = 1; |
|
410 |
}
|
|
411 |
||
412 |
venc->nmodes = 1; |
|
413 |
venc->modes = av_malloc(sizeof(vorbis_enc_mode) * venc->nmodes); |
|
414 |
if (!venc->modes) |
|
415 |
return AVERROR(ENOMEM); |
|
416 |
||
417 |
// single mode
|
|
418 |
venc->modes[0].blockflag = 0; |
|
419 |
venc->modes[0].mapping = 0; |
|
420 |
||
421 |
venc->have_saved = 0; |
|
422 |
venc->saved = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); |
|
423 |
venc->samples = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1])); |
|
424 |
venc->floor = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); |
|
425 |
venc->coeffs = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); |
|
426 |
if (!venc->saved || !venc->samples || !venc->floor || !venc->coeffs) |
|
427 |
return AVERROR(ENOMEM); |
|
428 |
||
429 |
venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6]; |
|
430 |
venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6]; |
|
431 |
||
432 |
if ((ret = ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0, 1.0)) < 0) |
|
433 |
return ret; |
|
434 |
if ((ret = ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0)) < 0) |
|
435 |
return ret; |
|
436 |
||
437 |
return 0; |
|
438 |
}
|
|
439 |
||
440 |
static void put_float(PutBitContext *pb, float f) |
|
441 |
{
|
|
442 |
int exp, mant; |
|
443 |
uint32_t res = 0; |
|
444 |
mant = (int)ldexp(frexp(f, &exp), 20); |
|
445 |
exp += 788 - 20; |
|
446 |
if (mant < 0) { |
|
447 |
res |= (1U << 31); |
|
448 |
mant = -mant; |
|
449 |
}
|
|
450 |
res |= mant | (exp << 21); |
|
451 |
put_bits32(pb, res); |
|
452 |
}
|
|
453 |
||
454 |
static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb) |
|
455 |
{
|
|
456 |
int i; |
|
457 |
int ordered = 0; |
|
458 |
||
459 |
put_bits(pb, 24, 0x564342); //magic |
|
460 |
put_bits(pb, 16, cb->ndimensions); |
|
461 |
put_bits(pb, 24, cb->nentries); |
|
462 |
||
463 |
for (i = 1; i < cb->nentries; i++) |
|
464 |
if (cb->lens[i] < cb->lens[i-1]) |
|
465 |
break; |
|
466 |
if (i == cb->nentries) |
|
467 |
ordered = 1; |
|
468 |
||
469 |
put_bits(pb, 1, ordered); |
|
470 |
if (ordered) { |
|
471 |
int len = cb->lens[0]; |
|
472 |
put_bits(pb, 5, len - 1); |
|
473 |
i = 0; |
|
474 |
while (i < cb->nentries) { |
|
475 |
int j; |
|
476 |
for (j = 0; j+i < cb->nentries; j++) |
|
477 |
if (cb->lens[j+i] != len) |
|
478 |
break; |
|
479 |
put_bits(pb, ilog(cb->nentries - i), j); |
|
480 |
i += j; |
|
481 |
len++; |
|
482 |
}
|
|
483 |
} else { |
|
484 |
int sparse = 0; |
|
485 |
for (i = 0; i < cb->nentries; i++) |
|
486 |
if (!cb->lens[i]) |
|
487 |
break; |
|
488 |
if (i != cb->nentries) |
|
489 |
sparse = 1; |
|
490 |
put_bits(pb, 1, sparse); |
|
491 |
||
492 |
for (i = 0; i < cb->nentries; i++) { |
|
493 |
if (sparse) |
|
494 |
put_bits(pb, 1, !!cb->lens[i]); |
|
495 |
if (cb->lens[i]) |
|
496 |
put_bits(pb, 5, cb->lens[i] - 1); |
|
497 |
}
|
|
498 |
}
|
|
499 |
||
500 |
put_bits(pb, 4, cb->lookup); |
|
501 |
if (cb->lookup) { |
|
502 |
int tmp = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); |
|
503 |
int bits = ilog(cb->quantlist[0]); |
|
504 |
||
505 |
for (i = 1; i < tmp; i++) |
|
506 |
bits = FFMAX(bits, ilog(cb->quantlist[i])); |
|
507 |
||
508 |
put_float(pb, cb->min); |
|
509 |
put_float(pb, cb->delta); |
|
510 |
||
511 |
put_bits(pb, 4, bits - 1); |
|
512 |
put_bits(pb, 1, cb->seq_p); |
|
513 |
||
514 |
for (i = 0; i < tmp; i++) |
|
515 |
put_bits(pb, bits, cb->quantlist[i]); |
|
516 |
}
|
|
517 |
}
|
|
518 |
||
519 |
static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc) |
|
520 |
{
|
|
521 |
int i; |
|
522 |
||
523 |
put_bits(pb, 16, 1); // type, only floor1 is supported |
|
524 |
||
525 |
put_bits(pb, 5, fc->partitions); |
|
526 |
||
527 |
for (i = 0; i < fc->partitions; i++) |
|
528 |
put_bits(pb, 4, fc->partition_to_class[i]); |
|
529 |
||
530 |
for (i = 0; i < fc->nclasses; i++) { |
|
531 |
int j, books; |
|
532 |
||
533 |
put_bits(pb, 3, fc->classes[i].dim - 1); |
|
534 |
put_bits(pb, 2, fc->classes[i].subclass); |
|
535 |
||
536 |
if (fc->classes[i].subclass) |
|
537 |
put_bits(pb, 8, fc->classes[i].masterbook); |
|
538 |
||
539 |
books = (1 << fc->classes[i].subclass); |
|
540 |
||
541 |
for (j = 0; j < books; j++) |
|
542 |
put_bits(pb, 8, fc->classes[i].books[j] + 1); |
|
543 |
}
|
|
544 |
||
545 |
put_bits(pb, 2, fc->multiplier - 1); |
|
546 |
put_bits(pb, 4, fc->rangebits); |
|
547 |
||
548 |
for (i = 2; i < fc->values; i++) |
|
549 |
put_bits(pb, fc->rangebits, fc->list[i].x); |
|
550 |
}
|
|
551 |
||
552 |
static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc) |
|
553 |
{
|
|
554 |
int i; |
|
555 |
||
556 |
put_bits(pb, 16, rc->type); |
|
557 |
||
558 |
put_bits(pb, 24, rc->begin); |
|
559 |
put_bits(pb, 24, rc->end); |
|
560 |
put_bits(pb, 24, rc->partition_size - 1); |
|
561 |
put_bits(pb, 6, rc->classifications - 1); |
|
562 |
put_bits(pb, 8, rc->classbook); |
|
563 |
||
564 |
for (i = 0; i < rc->classifications; i++) { |
|
565 |
int j, tmp = 0; |
|
566 |
for (j = 0; j < 8; j++) |
|
567 |
tmp |= (rc->books[i][j] != -1) << j; |
|
568 |
||
569 |
put_bits(pb, 3, tmp & 7); |
|
570 |
put_bits(pb, 1, tmp > 7); |
|
571 |
||
572 |
if (tmp > 7) |
|
573 |
put_bits(pb, 5, tmp >> 3); |
|
574 |
}
|
|
575 |
||
576 |
for (i = 0; i < rc->classifications; i++) { |
|
577 |
int j; |
|
578 |
for (j = 0; j < 8; j++) |
|
579 |
if (rc->books[i][j] != -1) |
|
580 |
put_bits(pb, 8, rc->books[i][j]); |
|
581 |
}
|
|
582 |
}
|
|
583 |
||
584 |
static int put_main_header(vorbis_enc_context *venc, uint8_t **out) |
|
585 |
{
|
|
586 |
int i; |
|
587 |
PutBitContext pb; |
|
588 |
int len, hlens[3]; |
|
589 |
int buffer_len = 50000; |
|
590 |
uint8_t *buffer = av_mallocz(buffer_len), *p = buffer; |
|
591 |
if (!buffer) |
|
592 |
return AVERROR(ENOMEM); |
|
593 |
||
594 |
// identification header
|
|
595 |
init_put_bits(&pb, p, buffer_len); |
|
596 |
put_bits(&pb, 8, 1); //magic |
|
597 |
for (i = 0; "vorbis"[i]; i++) |
|
598 |
put_bits(&pb, 8, "vorbis"[i]); |
|
599 |
put_bits32(&pb, 0); // version |
|
600 |
put_bits(&pb, 8, venc->channels); |
|
601 |
put_bits32(&pb, venc->sample_rate); |
|
602 |
put_bits32(&pb, 0); // bitrate |
|
603 |
put_bits32(&pb, 0); // bitrate |
|
604 |
put_bits32(&pb, 0); // bitrate |
|
605 |
put_bits(&pb, 4, venc->log2_blocksize[0]); |
|
606 |
put_bits(&pb, 4, venc->log2_blocksize[1]); |
|
607 |
put_bits(&pb, 1, 1); // framing |
|
608 |
||
609 |
flush_put_bits(&pb); |
|
610 |
hlens[0] = put_bits_count(&pb) >> 3; |
|
611 |
buffer_len -= hlens[0]; |
|
612 |
p += hlens[0]; |
|
613 |
||
614 |
// comment header
|
|
615 |
init_put_bits(&pb, p, buffer_len); |
|
616 |
put_bits(&pb, 8, 3); //magic |
|
617 |
for (i = 0; "vorbis"[i]; i++) |
|
618 |
put_bits(&pb, 8, "vorbis"[i]); |
|
619 |
put_bits32(&pb, 0); // vendor length TODO |
|
620 |
put_bits32(&pb, 0); // amount of comments |
|
621 |
put_bits(&pb, 1, 1); // framing |
|
622 |
||
623 |
flush_put_bits(&pb); |
|
624 |
hlens[1] = put_bits_count(&pb) >> 3; |
|
625 |
buffer_len -= hlens[1]; |
|
626 |
p += hlens[1]; |
|
627 |
||
628 |
// setup header
|
|
629 |
init_put_bits(&pb, p, buffer_len); |
|
630 |
put_bits(&pb, 8, 5); //magic |
|
631 |
for (i = 0; "vorbis"[i]; i++) |
|
632 |
put_bits(&pb, 8, "vorbis"[i]); |
|
633 |
||
634 |
// codebooks
|
|
635 |
put_bits(&pb, 8, venc->ncodebooks - 1); |
|
636 |
for (i = 0; i < venc->ncodebooks; i++) |
|
637 |
put_codebook_header(&pb, &venc->codebooks[i]); |
|
638 |
||
639 |
// time domain, reserved, zero
|
|
640 |
put_bits(&pb, 6, 0); |
|
641 |
put_bits(&pb, 16, 0); |
|
642 |
||
643 |
// floors
|
|
644 |
put_bits(&pb, 6, venc->nfloors - 1); |
|
645 |
for (i = 0; i < venc->nfloors; i++) |
|
646 |
put_floor_header(&pb, &venc->floors[i]); |
|
647 |
||
648 |
// residues
|
|
649 |
put_bits(&pb, 6, venc->nresidues - 1); |
|
650 |
for (i = 0; i < venc->nresidues; i++) |
|
651 |
put_residue_header(&pb, &venc->residues[i]); |
|
652 |
||
653 |
// mappings
|
|
654 |
put_bits(&pb, 6, venc->nmappings - 1); |
|
655 |
for (i = 0; i < venc->nmappings; i++) { |
|
656 |
vorbis_enc_mapping *mc = &venc->mappings[i]; |
|
657 |
int j; |
|
658 |
put_bits(&pb, 16, 0); // mapping type |
|
659 |
||
660 |
put_bits(&pb, 1, mc->submaps > 1); |
|
661 |
if (mc->submaps > 1) |
|
662 |
put_bits(&pb, 4, mc->submaps - 1); |
|
663 |
||
664 |
put_bits(&pb, 1, !!mc->coupling_steps); |
|
665 |
if (mc->coupling_steps) { |
|
666 |
put_bits(&pb, 8, mc->coupling_steps - 1); |
|
667 |
for (j = 0; j < mc->coupling_steps; j++) { |
|
668 |
put_bits(&pb, ilog(venc->channels - 1), mc->magnitude[j]); |
|
669 |
put_bits(&pb, ilog(venc->channels - 1), mc->angle[j]); |
|
670 |
}
|
|
671 |
}
|
|
672 |
||
673 |
put_bits(&pb, 2, 0); // reserved |
|
674 |
||
675 |
if (mc->submaps > 1) |
|
676 |
for (j = 0; j < venc->channels; j++) |
|
677 |
put_bits(&pb, 4, mc->mux[j]); |
|
678 |
||
679 |
for (j = 0; j < mc->submaps; j++) { |
|
680 |
put_bits(&pb, 8, 0); // reserved time configuration |
|
681 |
put_bits(&pb, 8, mc->floor[j]); |
|
682 |
put_bits(&pb, 8, mc->residue[j]); |
|
683 |
}
|
|
684 |
}
|
|
685 |
||
686 |
// modes
|
|
687 |
put_bits(&pb, 6, venc->nmodes - 1); |
|
688 |
for (i = 0; i < venc->nmodes; i++) { |
|
689 |
put_bits(&pb, 1, venc->modes[i].blockflag); |
|
690 |
put_bits(&pb, 16, 0); // reserved window type |
|
691 |
put_bits(&pb, 16, 0); // reserved transform type |
|
692 |
put_bits(&pb, 8, venc->modes[i].mapping); |
|
693 |
}
|
|
694 |
||
695 |
put_bits(&pb, 1, 1); // framing |
|
696 |
||
697 |
flush_put_bits(&pb); |
|
698 |
hlens[2] = put_bits_count(&pb) >> 3; |
|
699 |
||
700 |
len = hlens[0] + hlens[1] + hlens[2]; |
|
701 |
p = *out = av_mallocz(64 + len + len/255); |
|
702 |
if (!p) |
|
703 |
return AVERROR(ENOMEM); |
|
704 |
||
705 |
*p++ = 2; |
|
706 |
p += av_xiphlacing(p, hlens[0]); |
|
707 |
p += av_xiphlacing(p, hlens[1]); |
|
708 |
buffer_len = 0; |
|
709 |
for (i = 0; i < 3; i++) { |
|
710 |
memcpy(p, buffer + buffer_len, hlens[i]); |
|
711 |
p += hlens[i]; |
|
712 |
buffer_len += hlens[i]; |
|
713 |
}
|
|
714 |
||
715 |
av_freep(&buffer); |
|
716 |
return p - *out; |
|
717 |
}
|
|
718 |
||
719 |
static float get_floor_average(vorbis_enc_floor * fc, float *coeffs, int i) |
|
720 |
{
|
|
721 |
int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x; |
|
722 |
int end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x; |
|
723 |
int j; |
|
724 |
float average = 0; |
|
725 |
||
726 |
for (j = begin; j < end; j++) |
|
727 |
average += fabs(coeffs[j]); |
|
728 |
return average / (end - begin); |
|
729 |
}
|
|
730 |
||
731 |
static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc, |
|
732 |
float *coeffs, uint16_t *posts, int samples) |
|
733 |
{
|
|
734 |
int range = 255 / fc->multiplier + 1; |
|
735 |
int i; |
|
736 |
float tot_average = 0.0; |
|
737 |
float averages[MAX_FLOOR_VALUES]; |
|
738 |
for (i = 0; i < fc->values; i++) { |
|
739 |
averages[i] = get_floor_average(fc, coeffs, i); |
|
740 |
tot_average += averages[i]; |
|
741 |
}
|
|
742 |
tot_average /= fc->values; |
|
743 |
tot_average /= venc->quality; |
|
744 |
||
745 |
for (i = 0; i < fc->values; i++) { |
|
746 |
int position = fc->list[fc->list[i].sort].x; |
|
747 |
float average = averages[i]; |
|
748 |
int j; |
|
749 |
||
750 |
average = sqrt(tot_average * average) * pow(1.25f, position*0.005f); // MAGIC! |
|
751 |
for (j = 0; j < range - 1; j++) |
|
752 |
if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) |
|
753 |
break; |
|
754 |
posts[fc->list[i].sort] = j; |
|
755 |
}
|
|
756 |
}
|
|
757 |
||
758 |
static int render_point(int x0, int y0, int x1, int y1, int x) |
|
759 |
{
|
|
760 |
return y0 + (x - x0) * (y1 - y0) / (x1 - x0); |
|
761 |
}
|
|
762 |
||
763 |
static int floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc, |
|
764 |
PutBitContext *pb, uint16_t *posts, |
|
765 |
float *floor, int samples) |
|
766 |
{
|
|
767 |
int range = 255 / fc->multiplier + 1; |
|
768 |
int coded[MAX_FLOOR_VALUES]; // first 2 values are unused |
|
769 |
int i, counter; |
|
770 |
||
771 |
if (pb->size_in_bits - put_bits_count(pb) < 1 + 2 * ilog(range - 1)) |
|
772 |
return AVERROR(EINVAL); |
|
773 |
put_bits(pb, 1, 1); // non zero |
|
774 |
put_bits(pb, ilog(range - 1), posts[0]); |
|
775 |
put_bits(pb, ilog(range - 1), posts[1]); |
|
776 |
coded[0] = coded[1] = 1; |
|
777 |
||
778 |
for (i = 2; i < fc->values; i++) { |
|
779 |
int predicted = render_point(fc->list[fc->list[i].low].x, |
|
780 |
posts[fc->list[i].low], |
|
781 |
fc->list[fc->list[i].high].x, |
|
782 |
posts[fc->list[i].high], |
|
783 |
fc->list[i].x); |
|
784 |
int highroom = range - predicted; |
|
785 |
int lowroom = predicted; |
|
786 |
int room = FFMIN(highroom, lowroom); |
|
787 |
if (predicted == posts[i]) { |
|
788 |
coded[i] = 0; // must be used later as flag! |
|
789 |
continue; |
|
790 |
} else { |
|
791 |
if (!coded[fc->list[i].low ]) |
|
792 |
coded[fc->list[i].low ] = -1; |
|
793 |
if (!coded[fc->list[i].high]) |
|
794 |
coded[fc->list[i].high] = -1; |
|
795 |
}
|
|
796 |
if (posts[i] > predicted) { |
|
797 |
if (posts[i] - predicted > room) |
|
798 |
coded[i] = posts[i] - predicted + lowroom; |
|
799 |
else
|
|
800 |
coded[i] = (posts[i] - predicted) << 1; |
|
801 |
} else { |
|
802 |
if (predicted - posts[i] > room) |
|
803 |
coded[i] = predicted - posts[i] + highroom - 1; |
|
804 |
else
|
|
805 |
coded[i] = ((predicted - posts[i]) << 1) - 1; |
|
806 |
}
|
|
807 |
}
|
|
808 |
||
809 |
counter = 2; |
|
810 |
for (i = 0; i < fc->partitions; i++) { |
|
811 |
vorbis_enc_floor_class * c = &fc->classes[fc->partition_to_class[i]]; |
|
812 |
int k, cval = 0, csub = 1<<c->subclass; |
|
813 |
if (c->subclass) { |
|
814 |
vorbis_enc_codebook * book = &venc->codebooks[c->masterbook]; |
|
815 |
int cshift = 0; |
|
816 |
for (k = 0; k < c->dim; k++) { |
|
817 |
int l; |
|
818 |
for (l = 0; l < csub; l++) { |
|
819 |
int maxval = 1; |
|
820 |
if (c->books[l] != -1) |
|
821 |
maxval = venc->codebooks[c->books[l]].nentries; |
|
822 |
// coded could be -1, but this still works, cause that is 0
|
|
823 |
if (coded[counter + k] < maxval) |
|
824 |
break; |
|
825 |
}
|
|
826 |
assert(l != csub); |
|
827 |
cval |= l << cshift; |
|
828 |
cshift += c->subclass; |
|
829 |
}
|
|
830 |
if (put_codeword(pb, book, cval)) |
|
831 |
return AVERROR(EINVAL); |
|
832 |
}
|
|
833 |
for (k = 0; k < c->dim; k++) { |
|
834 |
int book = c->books[cval & (csub-1)]; |
|
835 |
int entry = coded[counter++]; |
|
836 |
cval >>= c->subclass; |
|
837 |
if (book == -1) |
|
838 |
continue; |
|
839 |
if (entry == -1) |
|
840 |
entry = 0; |
|
841 |
if (put_codeword(pb, &venc->codebooks[book], entry)) |
|
842 |
return AVERROR(EINVAL); |
|
843 |
}
|
|
844 |
}
|
|
845 |
||
846 |
ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded, |
|
847 |
fc->multiplier, floor, samples); |
|
848 |
||
849 |
return 0; |
|
850 |
}
|
|
851 |
||
852 |
static float *put_vector(vorbis_enc_codebook *book, PutBitContext *pb, |
|
853 |
float *num) |
|
854 |
{
|
|
855 |
int i, entry = -1; |
|
856 |
float distance = FLT_MAX; |
|
857 |
assert(book->dimensions); |
|
858 |
for (i = 0; i < book->nentries; i++) { |
|
859 |
float * vec = book->dimensions + i * book->ndimensions, d = book->pow2[i]; |
|
860 |
int j; |
|
861 |
if (!book->lens[i]) |
|
862 |
continue; |
|
863 |
for (j = 0; j < book->ndimensions; j++) |
|
864 |
d -= vec[j] * num[j]; |
|
865 |
if (distance > d) { |
|
866 |
entry = i; |
|
867 |
distance = d; |
|
868 |
}
|
|
869 |
}
|
|
870 |
if (put_codeword(pb, book, entry)) |
|
871 |
return NULL; |
|
872 |
return &book->dimensions[entry * book->ndimensions]; |
|
873 |
}
|
|
874 |
||
875 |
static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc, |
|
876 |
PutBitContext *pb, float *coeffs, int samples, |
|
877 |
int real_ch) |
|
878 |
{
|
|
879 |
int pass, i, j, p, k; |
|
880 |
int psize = rc->partition_size; |
|
881 |
int partitions = (rc->end - rc->begin) / psize; |
|
882 |
int channels = (rc->type == 2) ? 1 : real_ch; |
|
883 |
int classes[MAX_CHANNELS][NUM_RESIDUE_PARTITIONS]; |
|
884 |
int classwords = venc->codebooks[rc->classbook].ndimensions; |
|
885 |
||
886 |
av_assert0(rc->type == 2); |
|
887 |
av_assert0(real_ch == 2); |
|
888 |
for (p = 0; p < partitions; p++) { |
|
889 |
float max1 = 0.0, max2 = 0.0; |
|
890 |
int s = rc->begin + p * psize; |
|
891 |
for (k = s; k < s + psize; k += 2) { |
|
892 |
max1 = FFMAX(max1, fabs(coeffs[ k / real_ch])); |
|
893 |
max2 = FFMAX(max2, fabs(coeffs[samples + k / real_ch])); |
|
894 |
}
|
|
895 |
||
896 |
for (i = 0; i < rc->classifications - 1; i++) |
|
897 |
if (max1 < rc->maxes[i][0] && max2 < rc->maxes[i][1]) |
|
898 |
break; |
|
899 |
classes[0][p] = i; |
|
900 |
}
|
|
901 |
||
902 |
for (pass = 0; pass < 8; pass++) { |
|
903 |
p = 0; |
|
904 |
while (p < partitions) { |
|
905 |
if (pass == 0) |
|
906 |
for (j = 0; j < channels; j++) { |
|
907 |
vorbis_enc_codebook * book = &venc->codebooks[rc->classbook]; |
|
908 |
int entry = 0; |
|
909 |
for (i = 0; i < classwords; i++) { |
|
910 |
entry *= rc->classifications; |
|
911 |
entry += classes[j][p + i]; |
|
912 |
}
|
|
913 |
if (put_codeword(pb, book, entry)) |
|
914 |
return AVERROR(EINVAL); |
|
915 |
}
|
|
916 |
for (i = 0; i < classwords && p < partitions; i++, p++) { |
|
917 |
for (j = 0; j < channels; j++) { |
|
918 |
int nbook = rc->books[classes[j][p]][pass]; |
|
919 |
vorbis_enc_codebook * book = &venc->codebooks[nbook]; |
|
920 |
float *buf = coeffs + samples*j + rc->begin + p*psize; |
|
921 |
if (nbook == -1) |
|
922 |
continue; |
|
923 |
||
924 |
assert(rc->type == 0 || rc->type == 2); |
|
925 |
assert(!(psize % book->ndimensions)); |
|
926 |
||
927 |
if (rc->type == 0) { |
|
928 |
for (k = 0; k < psize; k += book->ndimensions) { |
|
929 |
int l; |
|
930 |
float *a = put_vector(book, pb, &buf[k]); |
|
931 |
if (!a) |
|
932 |
return AVERROR(EINVAL); |
|
933 |
for (l = 0; l < book->ndimensions; l++) |
|
934 |
buf[k + l] -= a[l]; |
|
935 |
}
|
|
936 |
} else { |
|
937 |
int s = rc->begin + p * psize, a1, b1; |
|
938 |
a1 = (s % real_ch) * samples; |
|
939 |
b1 = s / real_ch; |
|
940 |
s = real_ch * samples; |
|
941 |
for (k = 0; k < psize; k += book->ndimensions) { |
|
942 |
int dim, a2 = a1, b2 = b1; |
|
943 |
float vec[MAX_CODEBOOK_DIM], *pv = vec; |
|
944 |
for (dim = book->ndimensions; dim--; ) { |
|
945 |
*pv++ = coeffs[a2 + b2]; |
|
946 |
if ((a2 += samples) == s) { |
|
947 |
a2 = 0; |
|
948 |
b2++; |
|
949 |
}
|
|
950 |
}
|
|
951 |
pv = put_vector(book, pb, vec); |
|
952 |
if (!pv) |
|
953 |
return AVERROR(EINVAL); |
|
954 |
for (dim = book->ndimensions; dim--; ) { |
|
955 |
coeffs[a1 + b1] -= *pv++; |
|
956 |
if ((a1 += samples) == s) { |
|
957 |
a1 = 0; |
|
958 |
b1++; |
|
959 |
}
|
|
960 |
}
|
|
961 |
}
|
|
962 |
}
|
|
963 |
}
|
|
964 |
}
|
|
965 |
}
|
|
966 |
}
|
|
967 |
return 0; |
|
968 |
}
|
|
969 |
||
970 |
static int apply_window_and_mdct(vorbis_enc_context *venc, |
|
971 |
float **audio, int samples) |
|
972 |
{
|
|
973 |
int i, channel; |
|
974 |
const float * win = venc->win[0]; |
|
975 |
int window_len = 1 << (venc->log2_blocksize[0] - 1); |
|
976 |
float n = (float)(1 << venc->log2_blocksize[0]) / 4.0; |
|
977 |
// FIXME use dsp
|
|
978 |
||
979 |
if (!venc->have_saved && !samples) |
|
980 |
return 0; |
|
981 |
||
982 |
if (venc->have_saved) { |
|
983 |
for (channel = 0; channel < venc->channels; channel++) |
|
984 |
memcpy(venc->samples + channel * window_len * 2, |
|
985 |
venc->saved + channel * window_len, sizeof(float) * window_len); |
|
986 |
} else { |
|
987 |
for (channel = 0; channel < venc->channels; channel++) |
|
988 |
memset(venc->samples + channel * window_len * 2, 0, |
|
989 |
sizeof(float) * window_len); |
|
990 |
}
|
|
991 |
||
992 |
if (samples) { |
|
993 |
for (channel = 0; channel < venc->channels; channel++) { |
|
994 |
float * offset = venc->samples + channel*window_len*2 + window_len; |
|
995 |
for (i = 0; i < samples; i++) |
|
996 |
offset[i] = audio[channel][i] / n * win[window_len - i - 1]; |
|
997 |
}
|
|
998 |
} else { |
|
999 |
for (channel = 0; channel < venc->channels; channel++) |
|
1000 |
memset(venc->samples + channel * window_len * 2 + window_len, |
|
1001 |
0, sizeof(float) * window_len); |
|
1002 |
}
|
|
1003 |
||
1004 |
for (channel = 0; channel < venc->channels; channel++) |
|
1005 |
venc->mdct[0].mdct_calc(&venc->mdct[0], venc->coeffs + channel * window_len, |
|
1006 |
venc->samples + channel * window_len * 2); |
|
1007 |
||
1008 |
if (samples) { |
|
1009 |
for (channel = 0; channel < venc->channels; channel++) { |
|
1010 |
float *offset = venc->saved + channel * window_len; |
|
1011 |
for (i = 0; i < samples; i++) |
|
1012 |
offset[i] = audio[channel][i] / n * win[i]; |
|
1013 |
}
|
|
1014 |
venc->have_saved = 1; |
|
1015 |
} else { |
|
1016 |
venc->have_saved = 0; |
|
1017 |
}
|
|
1018 |
return 1; |
|
1019 |
}
|
|
1020 |
||
1021 |
static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, |
|
1022 |
const AVFrame *frame, int *got_packet_ptr) |
|
1023 |
{
|
|
1024 |
vorbis_enc_context *venc = avctx->priv_data; |
|
1025 |
float **audio = frame ? (float **)frame->extended_data : NULL; |
|
1026 |
int samples = frame ? frame->nb_samples : 0; |
|
1027 |
vorbis_enc_mode *mode; |
|
1028 |
vorbis_enc_mapping *mapping; |
|
1029 |
PutBitContext pb; |
|
1030 |
int i, ret; |
|
1031 |
||
1032 |
if (!apply_window_and_mdct(venc, audio, samples)) |
|
1033 |
return 0; |
|
1034 |
samples = 1 << (venc->log2_blocksize[0] - 1); |
|
1035 |
||
1036 |
if ((ret = ff_alloc_packet2(avctx, avpkt, 8192)) < 0) |
|
1037 |
return ret; |
|
1038 |
||
1039 |
init_put_bits(&pb, avpkt->data, avpkt->size); |
|
1040 |
||
1041 |
if (pb.size_in_bits - put_bits_count(&pb) < 1 + ilog(venc->nmodes - 1)) { |
|
1042 |
av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); |
|
1043 |
return AVERROR(EINVAL); |
|
1044 |
}
|
|
1045 |
||
1046 |
put_bits(&pb, 1, 0); // magic bit |
|
1047 |
||
1048 |
put_bits(&pb, ilog(venc->nmodes - 1), 0); // 0 bits, the mode |
|
1049 |
||
1050 |
mode = &venc->modes[0]; |
|
1051 |
mapping = &venc->mappings[mode->mapping]; |
|
1052 |
if (mode->blockflag) { |
|
1053 |
put_bits(&pb, 1, 0); |
|
1054 |
put_bits(&pb, 1, 0); |
|
1055 |
}
|
|
1056 |
||
1057 |
for (i = 0; i < venc->channels; i++) { |
|
1058 |
vorbis_enc_floor *fc = &venc->floors[mapping->floor[mapping->mux[i]]]; |
|
1059 |
uint16_t posts[MAX_FLOOR_VALUES]; |
|
1060 |
floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples); |
|
1061 |
if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples)) { |
|
1062 |
av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); |
|
1063 |
return AVERROR(EINVAL); |
|
1064 |
}
|
|
1065 |
}
|
|
1066 |
||
1067 |
for (i = 0; i < venc->channels * samples; i++) |
|
1068 |
venc->coeffs[i] /= venc->floor[i]; |
|
1069 |
||
1070 |
for (i = 0; i < mapping->coupling_steps; i++) { |
|
1071 |
float *mag = venc->coeffs + mapping->magnitude[i] * samples; |
|
1072 |
float *ang = venc->coeffs + mapping->angle[i] * samples; |
|
1073 |
int j; |
|
1074 |
for (j = 0; j < samples; j++) { |
|
1075 |
float a = ang[j]; |
|
1076 |
ang[j] -= mag[j]; |
|
1077 |
if (mag[j] > 0) |
|
1078 |
ang[j] = -ang[j]; |
|
1079 |
if (ang[j] < 0) |
|
1080 |
mag[j] = a; |
|
1081 |
}
|
|
1082 |
}
|
|
1083 |
||
1084 |
if (residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], |
|
1085 |
&pb, venc->coeffs, samples, venc->channels)) { |
|
1086 |
av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); |
|
1087 |
return AVERROR(EINVAL); |
|
1088 |
}
|
|
1089 |
||
1090 |
flush_put_bits(&pb); |
|
1091 |
avpkt->size = put_bits_count(&pb) >> 3; |
|
1092 |
||
1093 |
avpkt->duration = ff_samples_to_time_base(avctx, avctx->frame_size); |
|
1094 |
if (frame) { |
|
1095 |
if (frame->pts != AV_NOPTS_VALUE) |
|
1096 |
avpkt->pts = ff_samples_to_time_base(avctx, frame->pts); |
|
1097 |
} else { |
|
1098 |
avpkt->pts = venc->next_pts; |
|
1099 |
}
|
|
1100 |
if (avpkt->pts != AV_NOPTS_VALUE) |
|
1101 |
venc->next_pts = avpkt->pts + avpkt->duration; |
|
1102 |
||
1103 |
*got_packet_ptr = 1; |
|
1104 |
return 0; |
|
1105 |
}
|
|
1106 |
||
1107 |
||
1108 |
static av_cold int vorbis_encode_close(AVCodecContext *avctx) |
|
1109 |
{
|
|
1110 |
vorbis_enc_context *venc = avctx->priv_data; |
|
1111 |
int i; |
|
1112 |
||
1113 |
if (venc->codebooks) |
|
1114 |
for (i = 0; i < venc->ncodebooks; i++) { |
|
1115 |
av_freep(&venc->codebooks[i].lens); |
|
1116 |
av_freep(&venc->codebooks[i].codewords); |
|
1117 |
av_freep(&venc->codebooks[i].quantlist); |
|
1118 |
av_freep(&venc->codebooks[i].dimensions); |
|
1119 |
av_freep(&venc->codebooks[i].pow2); |
|
1120 |
}
|
|
1121 |
av_freep(&venc->codebooks); |
|
1122 |
||
1123 |
if (venc->floors) |
|
1124 |
for (i = 0; i < venc->nfloors; i++) { |
|
1125 |
int j; |
|
1126 |
if (venc->floors[i].classes) |
|
1127 |
for (j = 0; j < venc->floors[i].nclasses; j++) |
|
1128 |
av_freep(&venc->floors[i].classes[j].books); |
|
1129 |
av_freep(&venc->floors[i].classes); |
|
1130 |
av_freep(&venc->floors[i].partition_to_class); |
|
1131 |
av_freep(&venc->floors[i].list); |
|
1132 |
}
|
|
1133 |
av_freep(&venc->floors); |
|
1134 |
||
1135 |
if (venc->residues) |
|
1136 |
for (i = 0; i < venc->nresidues; i++) { |
|
1137 |
av_freep(&venc->residues[i].books); |
|
1138 |
av_freep(&venc->residues[i].maxes); |
|
1139 |
}
|
|
1140 |
av_freep(&venc->residues); |
|
1141 |
||
1142 |
if (venc->mappings) |
|
1143 |
for (i = 0; i < venc->nmappings; i++) { |
|
1144 |
av_freep(&venc->mappings[i].mux); |
|
1145 |
av_freep(&venc->mappings[i].floor); |
|
1146 |
av_freep(&venc->mappings[i].residue); |
|
1147 |
av_freep(&venc->mappings[i].magnitude); |
|
1148 |
av_freep(&venc->mappings[i].angle); |
|
1149 |
}
|
|
1150 |
av_freep(&venc->mappings); |
|
1151 |
||
1152 |
av_freep(&venc->modes); |
|
1153 |
||
1154 |
av_freep(&venc->saved); |
|
1155 |
av_freep(&venc->samples); |
|
1156 |
av_freep(&venc->floor); |
|
1157 |
av_freep(&venc->coeffs); |
|
1158 |
||
1159 |
ff_mdct_end(&venc->mdct[0]); |
|
1160 |
ff_mdct_end(&venc->mdct[1]); |
|
1161 |
||
1162 |
av_freep(&avctx->extradata); |
|
1163 |
||
1164 |
return 0 ; |
|
1165 |
}
|
|
1166 |
||
1167 |
static av_cold int vorbis_encode_init(AVCodecContext *avctx) |
|
1168 |
{
|
|
1169 |
vorbis_enc_context *venc = avctx->priv_data; |
|
1170 |
int ret; |
|
1171 |
||
1172 |
if (avctx->channels != 2) { |
|
1173 |
av_log(avctx, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n"); |
|
1174 |
return -1; |
|
1175 |
}
|
|
1176 |
||
1177 |
if ((ret = create_vorbis_context(venc, avctx)) < 0) |
|
1178 |
goto error; |
|
1179 |
||
1180 |
avctx->bit_rate = 0; |
|
1181 |
if (avctx->flags & CODEC_FLAG_QSCALE) |
|
1182 |
venc->quality = avctx->global_quality / (float)FF_QP2LAMBDA; |
|
1183 |
else
|
|
1184 |
venc->quality = 8; |
|
1185 |
venc->quality *= venc->quality; |
|
1186 |
||
1187 |
if ((ret = put_main_header(venc, (uint8_t**)&avctx->extradata)) < 0) |
|
1188 |
goto error; |
|
1189 |
avctx->extradata_size = ret; |
|
1190 |
||
1191 |
avctx->frame_size = 1 << (venc->log2_blocksize[0] - 1); |
|
1192 |
||
1193 |
return 0; |
|
1194 |
error: |
|
1195 |
vorbis_encode_close(avctx); |
|
1196 |
return ret; |
|
1197 |
}
|
|
1198 |
||
1199 |
AVCodec ff_vorbis_encoder = { |
|
1200 |
.name = "vorbis", |
|
1201 |
.long_name = NULL_IF_CONFIG_SMALL("Vorbis"), |
|
1202 |
.type = AVMEDIA_TYPE_AUDIO, |
|
1203 |
.id = AV_CODEC_ID_VORBIS, |
|
1204 |
.priv_data_size = sizeof(vorbis_enc_context), |
|
1205 |
.init = vorbis_encode_init, |
|
1206 |
.encode2 = vorbis_encode_frame, |
|
1207 |
.close = vorbis_encode_close, |
|
1208 |
.capabilities = CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL, |
|
1209 |
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, |
|
1210 |
AV_SAMPLE_FMT_NONE }, |
|
1211 |
};
|