Original Commit: r114 | ods15 | 2006-10-01 21:38:37 +0200 (Sun, 01 Oct 2006) | 2...
[ffmpeg.git] / libavcodec / vorbis_enc.c
1 /*
2  * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 /**
20  * @file vorbis_enc.c
21  * Native Vorbis encoder.
22  * @author Oded Shimon <ods15@ods15.dyndns.org>
23  */
24
25 #include <float.h>
26 #include "avcodec.h"
27 #include "dsputil.h"
28 #include "vorbis.h"
29
30 #undef NDEBUG
31 #include <assert.h>
32
33 typedef struct {
34     int nentries;
35     uint8_t * lens;
36     uint32_t * codewords;
37     int ndimentions;
38     float min;
39     float delta;
40     int seq_p;
41     int lookup;
42     int * quantlist;
43     float * dimentions;
44     float * pow2;
45 } codebook_t;
46
47 typedef struct {
48     int dim;
49     int subclass;
50     int masterbook;
51     int * books;
52 } floor_class_t;
53
54 typedef struct {
55     int partitions;
56     int * partition_to_class;
57     int nclasses;
58     floor_class_t * classes;
59     int multiplier;
60     int rangebits;
61     int values;
62     floor1_entry_t * list;
63 } floor_t;
64
65 typedef struct {
66     int type;
67     int begin;
68     int end;
69     int partition_size;
70     int classifications;
71     int classbook;
72     int8_t (*books)[8];
73     float (*maxes)[2];
74 } residue_t;
75
76 typedef struct {
77     int submaps;
78     int * mux;
79     int * floor;
80     int * residue;
81     int coupling_steps;
82     int * magnitude;
83     int * angle;
84 } mapping_t;
85
86 typedef struct {
87     int blockflag;
88     int mapping;
89 } vorbis_mode_t;
90
91 typedef struct {
92     int channels;
93     int sample_rate;
94     int log2_blocksize[2];
95     MDCTContext mdct[2];
96     const float * win[2];
97     int have_saved;
98     float * saved;
99     float * samples;
100     float * floor; // also used for tmp values for mdct
101     float * coeffs; // also used for residue after floor
102     float quality;
103
104     int ncodebooks;
105     codebook_t * codebooks;
106
107     int nfloors;
108     floor_t * floors;
109
110     int nresidues;
111     residue_t * residues;
112
113     int nmappings;
114     mapping_t * mappings;
115
116     int nmodes;
117     vorbis_mode_t * modes;
118 } venc_context_t;
119
120 typedef struct {
121     int total;
122     int total_pos;
123     int pos;
124     uint8_t * buf_ptr;
125 } PutBitContext;
126
127 static const uint8_t codebook0[] = {
128    2, 10,  8, 14,  7, 12, 11, 14,  1,  5,  3,  7,  4,  9,  7,
129   13,
130 };
131
132 static const uint8_t codebook1[] = {
133    1,  4,  2,  6,  3,  7,  5,  7,
134 };
135
136 static const uint8_t codebook2[] = {
137    1,  5,  7, 21,  5,  8,  9, 21, 10,  9, 12, 20, 20, 16, 20,
138   20,  4,  8,  9, 20,  6,  8,  9, 20, 11, 11, 13, 20, 20, 15,
139   17, 20,  9, 11, 14, 20,  8, 10, 15, 20, 11, 13, 15, 20, 20,
140   20, 20, 20, 20, 20, 20, 20, 13, 20, 20, 20, 18, 18, 20, 20,
141   20, 20, 20, 20,  3,  6,  8, 20,  6,  7,  9, 20, 10,  9, 12,
142   20, 20, 20, 20, 20,  5,  7,  9, 20,  6,  6,  9, 20, 10,  9,
143   12, 20, 20, 20, 20, 20,  8, 10, 13, 20,  8,  9, 12, 20, 11,
144   10, 12, 20, 20, 20, 20, 20, 18, 20, 20, 20, 15, 17, 18, 20,
145   18, 17, 18, 20, 20, 20, 20, 20,  7, 10, 12, 20,  8,  9, 11,
146   20, 14, 13, 14, 20, 20, 20, 20, 20,  6,  9, 12, 20,  7,  8,
147   11, 20, 12, 11, 13, 20, 20, 20, 20, 20,  9, 11, 15, 20,  8,
148   10, 14, 20, 12, 11, 14, 20, 20, 20, 20, 20, 20, 20, 20, 20,
149   20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 11, 16, 18,
150   20, 15, 15, 17, 20, 20, 17, 20, 20, 20, 20, 20, 20,  9, 14,
151   16, 20, 12, 12, 15, 20, 17, 15, 18, 20, 20, 20, 20, 20, 16,
152   19, 18, 20, 15, 16, 20, 20, 17, 17, 20, 20, 20, 20, 20, 20,
153   20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
154   20,
155 };
156
157 static const uint8_t codebook3[] = {
158    2,  3,  7, 13,  4,  4,  7, 15,  8,  6,  9, 17, 21, 16, 15,
159   21,  2,  5,  7, 11,  5,  5,  7, 14,  9,  7, 10, 16, 17, 15,
160   16, 21,  4,  7, 10, 17,  7,  7,  9, 15, 11,  9, 11, 16, 21,
161   18, 15, 21, 18, 21, 21, 21, 15, 17, 17, 19, 21, 19, 18, 20,
162   21, 21, 21, 20,
163 };
164
165 static const uint8_t codebook4[] = {
166    5,  5,  5,  5,  6,  5,  6,  5,  6,  5,  6,  5,  6,  5,  6,
167    5,  6,  5,  6,  5,  6,  5,  6,  5,  7,  5,  7,  5,  7,  5,
168    7,  5,  8,  6,  8,  6,  8,  6,  9,  6,  9,  6, 10,  6, 10,
169    6, 11,  6, 11,  7, 11,  7, 12,  7, 12,  7, 12,  7, 12,  7,
170   12,  7, 12,  7, 12,  7, 12,  8, 13,  8, 12,  8, 12,  8, 13,
171    8, 13,  9, 13,  9, 13,  9, 13,  9, 12, 10, 12, 10, 13, 10,
172   14, 11, 14, 12, 14, 13, 14, 13, 14, 14, 15, 16, 15, 15, 15,
173   14, 15, 17, 21, 22, 22, 21, 22, 22, 22, 22, 22, 22, 21, 21,
174   21, 21, 21, 21, 21, 21, 21, 21,
175 };
176
177 static const uint8_t codebook5[] = {
178    2,  5,  5,  4,  5,  4,  5,  4,  5,  4,  6,  5,  6,  5,  6,
179    5,  6,  5,  7,  5,  7,  6,  8,  6,  8,  6,  8,  6,  9,  6,
180    9,  6,
181 };
182
183 static const uint8_t codebook6[] = {
184    8,  5,  8,  4,  9,  4,  9,  4,  9,  4,  9,  4,  9,  4,  9,
185    4,  9,  4,  9,  4,  9,  4,  8,  4,  8,  4,  9,  5,  9,  5,
186    9,  5,  9,  5,  9,  6, 10,  6, 10,  7, 10,  8, 11,  9, 11,
187   11, 12, 13, 12, 14, 13, 15, 13, 15, 14, 16, 14, 17, 15, 17,
188   15, 15, 16, 16, 15, 16, 16, 16, 15, 18, 16, 15, 17, 17, 19,
189   19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
190   19, 19, 19, 19, 19, 19,
191 };
192
193 static const uint8_t codebook7[] = {
194    1,  5,  5,  5,  5,  5,  5,  5,  6,  5,  6,  5,  6,  5,  6,
195    5,  6,  6,  7,  7,  7,  7,  8,  7,  8,  8,  9,  8, 10,  9,
196   10,  9,
197 };
198
199 static const uint8_t codebook8[] = {
200    4,  3,  4,  3,  4,  4,  5,  4,  5,  4,  5,  5,  6,  5,  6,
201    5,  7,  5,  7,  6,  7,  6,  8,  7,  8,  7,  8,  7,  9,  8,
202    9,  9,  9,  9, 10, 10, 10, 11,  9, 12,  9, 12,  9, 15, 10,
203   14,  9, 13, 10, 13, 10, 12, 10, 12, 10, 13, 10, 12, 11, 13,
204   11, 14, 12, 13, 13, 14, 14, 13, 14, 15, 14, 16, 13, 13, 14,
205   16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
206   16, 16, 16, 16, 15, 15,
207 };
208
209 static const uint8_t codebook9[] = {
210    4,  5,  4,  5,  3,  5,  3,  5,  3,  5,  4,  4,  4,  4,  5,
211    5,  5,
212 };
213
214 static const uint8_t codebook10[] = {
215    3,  3,  4,  3,  4,  4,  4,  4,  5,  5,  5,  5,  5,  6,  5,
216    7,  5,  8,  6,  8,  6,  9,  7, 10,  7, 10,  8, 10,  8, 11,
217    9, 11,
218 };
219
220 static const uint8_t codebook11[] = {
221    3,  7,  3,  8,  3, 10,  3,  8,  3,  9,  3,  8,  4,  9,  4,
222    9,  5,  9,  6, 10,  6,  9,  7, 11,  7, 12,  9, 13, 10, 13,
223   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
224   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
225   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
226   12, 12, 12,
227 };
228
229 static const uint8_t codebook12[] = {
230    4,  5,  4,  5,  4,  5,  4,  5,  3,  5,  3,  5,  3,  5,  4,
231    5,  4,
232 };
233
234 static const uint8_t codebook13[] = {
235    4,  2,  4,  2,  5,  3,  5,  4,  6,  6,  6,  7,  7,  8,  7,
236    8,  7,  8,  7,  9,  8,  9,  8,  9,  8, 10,  8, 11,  9, 12,
237    9, 12,
238 };
239
240 static const uint8_t codebook14[] = {
241    2,  5,  2,  6,  3,  6,  4,  7,  4,  7,  5,  9,  5, 11,  6,
242   11,  6, 11,  7, 11,  6, 11,  6, 11,  9, 11,  8, 11, 11, 11,
243   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
244   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
245   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 10,
246   10, 10, 10,
247 };
248
249 static const uint8_t codebook15[] = {
250    5,  6, 11, 11, 11, 11, 10, 10, 12, 11,  5,  2, 11,  5,  6,
251    6,  7,  9, 11, 13, 13, 10,  7, 11,  6,  7,  8,  9, 10, 12,
252   11,  5, 11,  6,  8,  7,  9, 11, 14, 15, 11,  6,  6,  8,  4,
253    5,  7,  8, 10, 13, 10,  5,  7,  7,  5,  5,  6,  8, 10, 11,
254   10,  7,  7,  8,  6,  5,  5,  7,  9,  9, 11,  8,  8, 11,  8,
255    7,  6,  6,  7,  9, 12, 11, 10, 13,  9,  9,  7,  7,  7,  9,
256   11, 13, 12, 15, 12, 11,  9,  8,  8,  8,
257 };
258
259 static const uint8_t codebook16[] = {
260    2,  4,  4,  0,  0,  0,  0,  0,  0,  5,  6,  6,  0,  0,  0,
261    0,  0,  0,  5,  6,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,
262    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
263    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
264    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
265    0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,  0,  0,  0,
266    7,  8,  8,  0,  0,  0,  0,  0,  0,  6,  7,  8,  0,  0,  0,
267    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
268    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
269    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
270    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,
271    0,  0,  0,  0,  0,  0,  6,  8,  7,  0,  0,  0,  0,  0,  0,
272    7,  8,  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
273    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
274    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
275    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
276    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
277    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
278    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
279    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
280    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
281    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
282    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
283    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
284    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
285    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
286    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
287    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
288    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
289    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
290    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
291    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
292    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
293    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
294    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
295    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
296    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
297    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
298    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
299    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
300    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
301    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
302    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
303    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
304    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
305    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
306    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
307    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
308    0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,
309    0,  0,  0,  7,  8,  8,  0,  0,  0,  0,  0,  0,  7,  8,  8,
310    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
311    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
312    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
313    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
314    7,  8,  8,  0,  0,  0,  0,  0,  0,  8,  8,  9,  0,  0,  0,
315    0,  0,  0,  8,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,
316    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
317    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
318    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
319    0,  0,  0,  0,  0,  0,  6,  8,  8,  0,  0,  0,  0,  0,  0,
320    7,  9,  8,  0,  0,  0,  0,  0,  0,  8,  9,  9,  0,  0,  0,
321    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
322    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
323    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
324    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
325    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
326    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
327    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
328    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
329    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
330    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
331    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
332    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
333    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
334    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
335    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
336    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
337    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
338    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
339    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
340    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
341    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
342    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
343    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
344    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
345    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
346    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
347    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
348    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
349    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
350    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
351    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
352    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
353    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
354    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
355    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
356    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
357    0,  0,  0,  5,  7,  7,  0,  0,  0,  0,  0,  0,  7,  8,  8,
358    0,  0,  0,  0,  0,  0,  7,  8,  8,  0,  0,  0,  0,  0,  0,
359    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
360    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
361    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
362    0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  8,  8,  0,  0,  0,
363    0,  0,  0,  8,  9,  9,  0,  0,  0,  0,  0,  0,  7,  8,  9,
364    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
365    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
366    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
367    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
368    6,  8,  8,  0,  0,  0,  0,  0,  0,  8,  9,  9,  0,  0,  0,
369    0,  0,  0,  8,  9,  8,
370 };
371
372 static const uint8_t codebook17[] = {
373    2,  5,  5,  0,  0,  0,  5,  5,  0,  0,  0,  5,  5,  0,  0,
374    0,  7,  8,  0,  0,  0,  0,  0,  0,  0,  5,  6,  6,  0,  0,
375    0,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0, 10, 10,  0,  0,
376    0,  0,  0,  0,  0,  5,  6,  6,  0,  0,  0,  7,  7,  0,  0,
377    0,  7,  7,  0,  0,  0, 10, 10,  0,  0,  0,  0,  0,  0,  0,
378    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
379    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
380    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
381    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
382    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
383    5,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  7,  7,  0,  0,
384    0,  9,  9,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,
385    0,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  9,  9,  0,  0,
386    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
387    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
388    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
389    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
390    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
391    0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,  7,  7,  0,  0,
392    0,  7,  7,  0,  0,  0,  9,  9,  0,  0,  0,  0,  0,  0,  0,
393    5,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  7,  7,  0,  0,
394    0,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
395    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
396    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
397    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
398    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
399    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8, 10, 10,  0,  0,
400    0,  9,  9,  0,  0,  0,  9,  9,  0,  0,  0, 10, 10,  0,  0,
401    0,  0,  0,  0,  0,  8, 10, 10,  0,  0,  0,  9,  9,  0,  0,
402    0,  9,  9,  0,  0,  0, 10, 10,
403 };
404
405 static const uint8_t codebook18[] = {
406    2,  4,  3,  6,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
407    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  4,  4,  6,  6,
408    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
409    0,  0,  0,  0,  0,  4,  4,  4,  6,  6,  0,  0,  0,  0,  0,
410    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
411    6,  6,  6,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
412    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  6,  7,  9,  9,
413 };
414
415 static const uint8_t codebook19[] = {
416    2,  3,  3,  6,  6,  0,  0,  0,  0,  0,  4,  4,  6,  6,  0,
417    0,  0,  0,  0,  4,  4,  6,  6,  0,  0,  0,  0,  0,  5,  5,
418    6,  6,  0,  0,  0,  0,  0,  0,  0,  6,  6,  0,  0,  0,  0,
419    0,  0,  0,  7,  8,  0,  0,  0,  0,  0,  0,  0,  7,  7,  0,
420    0,  0,  0,  0,  0,  0,  9,  9,
421 };
422
423 static const uint8_t codebook20[] = {
424    1,  3,  4,  6,  6,  7,  7,  9,  9,  0,  5,  5,  7,  7,  7,
425    8,  9,  9,  0,  5,  5,  7,  7,  8,  8,  9,  9,  0,  7,  7,
426    8,  8,  8,  8, 10, 10,  0,  0,  0,  8,  8,  8,  8, 10, 10,
427    0,  0,  0,  9,  9,  9,  9, 10, 10,  0,  0,  0,  9,  9,  9,
428    9, 10, 10,  0,  0,  0, 10, 10, 10, 10, 11, 11,  0,  0,  0,
429    0,  0, 10, 10, 11, 11,
430 };
431
432 static const uint8_t codebook21[] = {
433    2,  3,  3,  6,  6,  7,  7,  8,  8,  8,  8,  9,  9, 10, 10,
434   11, 10,  0,  5,  5,  7,  7,  8,  8,  9,  9,  9,  9, 10, 10,
435   10, 10, 11, 11,  0,  5,  5,  7,  7,  8,  8,  9,  9,  9,  9,
436   10, 10, 10, 10, 11, 11,  0,  6,  6,  7,  7,  8,  8,  9,  9,
437    9,  9, 10, 10, 11, 11, 11, 11,  0,  0,  0,  7,  7,  8,  8,
438    9,  9,  9,  9, 10, 10, 11, 11, 11, 12,  0,  0,  0,  8,  8,
439    8,  8,  9,  9,  9,  9, 10, 10, 11, 11, 12, 12,  0,  0,  0,
440    8,  8,  8,  8,  9,  9,  9,  9, 10, 10, 11, 11, 12, 12,  0,
441    0,  0,  9,  9,  9,  9, 10, 10, 10, 10, 11, 10, 11, 11, 12,
442   12,  0,  0,  0,  0,  0,  9,  9, 10, 10, 10, 10, 11, 11, 11,
443   11, 12, 12,  0,  0,  0,  0,  0,  9,  8,  9,  9, 10, 10, 11,
444   11, 12, 12, 12, 12,  0,  0,  0,  0,  0,  8,  8,  9,  9, 10,
445   10, 11, 11, 12, 11, 12, 12,  0,  0,  0,  0,  0,  9, 10, 10,
446   10, 11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,  0,  0,
447    0, 10, 10, 10, 10, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,
448    0,  0,  0, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13,  0,  0,
449    0,  0,  0,  0,  0, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13,
450    0,  0,  0,  0,  0,  0,  0, 11, 11, 12, 12, 12, 12, 13, 13,
451   13, 13,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 12,
452   13, 13, 13, 13,
453 };
454
455 static const uint8_t codebook22[] = {
456    1,  4,  4,  7,  6,  6,  7,  6,  6,  4,  7,  7, 10,  9,  9,
457   11,  9,  9,  4,  7,  7, 10,  9,  9, 11,  9,  9,  7, 10, 10,
458   11, 11, 10, 12, 11, 11,  6,  9,  9, 11, 10, 10, 11, 10, 10,
459    6,  9,  9, 11, 10, 10, 11, 10, 10,  7, 11, 11, 11, 11, 11,
460   12, 11, 11,  6,  9,  9, 11, 10, 10, 11, 10, 10,  6,  9,  9,
461   11, 10, 10, 11, 10, 10,
462 };
463
464 static const uint8_t codebook23[] = {
465    2,  4,  4,  6,  6,  7,  7,  7,  7,  8,  8, 10,  5,  5,  6,
466    6,  7,  7,  8,  8,  8,  8, 10,  5,  5,  6,  6,  7,  7,  8,
467    8,  8,  8, 10,  6,  6,  7,  7,  8,  8,  8,  8,  8,  8, 10,
468   10, 10,  7,  7,  8,  7,  8,  8,  8,  8, 10, 10, 10,  8,  8,
469    8,  8,  8,  8,  8,  8, 10, 10, 10,  7,  8,  8,  8,  8,  8,
470    8,  8, 10, 10, 10,  8,  8,  8,  8,  8,  8,  8,  8, 10, 10,
471   10, 10, 10,  8,  8,  8,  8,  8,  8, 10, 10, 10, 10, 10,  9,
472    9,  8,  8,  9,  8, 10, 10, 10, 10, 10,  8,  8,  8,  8,  8,
473    8,
474 };
475
476 static const uint8_t codebook24[] = {
477    1,  4,  4,  6,  6,  7,  7,  8,  8,  9,  9, 10, 10,  6,  5,
478    5,  7,  7,  8,  8,  8,  8,  9,  9, 10, 10,  7,  5,  5,  7,
479    7,  8,  8,  8,  8,  9,  9, 11, 10,  0,  8,  8,  8,  8,  9,
480    9,  9,  9, 10, 10, 11, 11,  0,  8,  8,  8,  8,  9,  9,  9,
481    9, 10, 10, 11, 11,  0, 12, 12,  9,  9, 10, 10, 10, 10, 11,
482   11, 11, 12,  0, 13, 13,  9,  9, 10, 10, 10, 10, 11, 11, 12,
483   12,  0,  0,  0, 10, 10, 10, 10, 11, 11, 12, 12, 12, 12,  0,
484    0,  0, 10, 10, 10, 10, 11, 11, 12, 12, 12, 12,  0,  0,  0,
485   14, 14, 11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0, 14, 14,
486   11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,  0, 12, 12,
487   12, 12, 13, 13, 14, 13,  0,  0,  0,  0,  0, 13, 13, 12, 12,
488   13, 12, 14, 13,
489 };
490
491 static const uint8_t codebook25[] = {
492    2,  4,  4,  5,  5,  6,  5,  5,  5,  5,  6,  4,  5,  5,  5,
493    6,  5,  5,  5,  5,  6,  6,  6,  5,  5,
494 };
495
496 static const uint8_t codebook26[] = {
497    1,  4,  4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  4,  9,
498    8, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  2,  9,  7, 12,
499   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
500   12, 12, 12, 12, 12, 12, 12, 12, 12, 11, 12, 12, 12, 12, 12,
501   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
502   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
503   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
504   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
505   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
506   12, 12, 12, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
507   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
508   11, 11, 11, 11,
509 };
510
511 static const uint8_t codebook27[] = {
512    1,  4,  4,  6,  6,  7,  7,  8,  7,  9,  9, 10, 10, 10, 10,
513    6,  5,  5,  7,  7,  8,  8, 10,  8, 11, 10, 12, 12, 13, 13,
514    6,  5,  5,  7,  7,  8,  8, 10,  9, 11, 11, 12, 12, 13, 12,
515   18,  8,  8,  8,  8,  9,  9, 10,  9, 11, 10, 12, 12, 13, 13,
516   18,  8,  8,  8,  8,  9,  9, 10, 10, 11, 11, 13, 12, 14, 13,
517   18, 11, 11,  9,  9, 10, 10, 11, 11, 11, 12, 13, 12, 13, 14,
518   18, 11, 11,  9,  8, 11, 10, 11, 11, 11, 11, 12, 12, 14, 13,
519   18, 18, 18, 10, 11, 10, 11, 12, 12, 12, 12, 13, 12, 14, 13,
520   18, 18, 18, 10, 11, 11,  9, 12, 11, 12, 12, 12, 13, 13, 13,
521   18, 18, 17, 14, 14, 11, 11, 12, 12, 13, 12, 14, 12, 14, 13,
522   18, 18, 18, 14, 14, 11, 10, 12,  9, 12, 13, 13, 13, 13, 13,
523   18, 18, 17, 16, 18, 13, 13, 12, 12, 13, 11, 14, 12, 14, 14,
524   17, 18, 18, 17, 18, 13, 12, 13, 10, 12, 11, 14, 14, 14, 14,
525   17, 18, 18, 18, 18, 15, 16, 12, 12, 13, 10, 14, 12, 14, 15,
526   18, 18, 18, 16, 17, 16, 14, 12, 11, 13, 10, 13, 13, 14, 15,
527 };
528
529 static const uint8_t codebook28[] = {
530    2,  5,  5,  6,  6,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,
531    8,  8, 10,  6,  6,  7,  7,  8,  7,  8,  8,  8,  8,  8,  9,
532    9,  9,  9,  9, 10,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
533    9,  9,  9,  9,  9,  9, 10,  7,  7,  7,  7,  8,  8,  8,  8,
534    9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10,  7,  7,  8,  8,
535    8,  9,  9,  9,  9,  9,  9,  9,  9,  9, 11, 11, 11,  8,  8,
536    8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10,
537    8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10,
538   10, 10,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10,
539    9, 10, 10, 10, 11, 11,  9,  9,  9,  9,  9,  9,  9,  9,  9,
540    9,  9,  9, 11, 10, 11, 11, 11,  9,  9,  9,  9,  9,  9, 10,
541   10,  9,  9, 10,  9, 11, 10, 11, 11, 11,  9,  9,  9,  9,  9,
542    9,  9,  9, 10, 10, 10,  9, 11, 11, 11, 11, 11,  9,  9,  9,
543    9, 10, 10,  9,  9,  9,  9, 10,  9, 11, 11, 11, 11, 11, 11,
544   11,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 11,
545   11, 11, 11, 10,  9, 10, 10,  9, 10,  9,  9, 10,  9, 11, 10,
546   10, 11, 11, 11, 11,  9, 10,  9,  9,  9,  9, 10, 10, 10, 10,
547   11, 11, 11, 11, 11, 11, 10, 10, 10,  9,  9, 10,  9, 10,  9,
548   10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11,  9,  9,  9,  9,
549    9, 10, 10, 10,
550 };
551
552 static const struct {
553     int dim;
554     int len;
555     int real_len;
556     const uint8_t * clens;
557     int lookup;
558     float min;
559     float delta;
560     const uint8_t * quant;
561 } cvectors[] = {
562     { 2,   16,   16, codebook0,  0 },
563     { 2,    8,    8, codebook1,  0 },
564     { 2,  256,  256, codebook2,  0 },
565     { 2,   64,   64, codebook3,  0 },
566     { 2,  128,  128, codebook4,  0 },
567     { 2,   32,   32, codebook5,  0 },
568     { 2,   96,   96, codebook6,  0 },
569     { 2,   32,   32, codebook7,  0 },
570     { 2,   96,   96, codebook8,  0 },
571     { 2,   17,   17, codebook9,  0 },
572     { 2,   32,   32, codebook10, 0 },
573     { 2,   78,   78, codebook11, 0 },
574     { 2,   17,   17, codebook12, 0 },
575     { 2,   32,   32, codebook13, 0 },
576     { 2,   78,   78, codebook14, 0 },
577     { 2,  100,  100, codebook15, 0 },
578     { 8, 1641, 6561, codebook16, 1,    -1.0,   1.0, (const uint8_t[]){ 1, 0, 2, } },
579     { 4,  443,  625, codebook17, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },
580     { 4,  105,  625, codebook18, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },
581     { 2,   68,   81, codebook19, 1,    -4.0,   1.0, (const uint8_t[]){ 4, 3, 5, 2, 6, 1, 7, 0, 8, } },
582     { 2,   81,   81, codebook20, 1,    -4.0,   1.0, (const uint8_t[]){ 4, 3, 5, 2, 6, 1, 7, 0, 8, } },
583     { 2,  289,  289, codebook21, 1,    -8.0,   1.0, (const uint8_t[]){ 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, 0, 16, } },
584     { 4,   81,   81, codebook22, 1,   -11.0,  11.0, (const uint8_t[]){ 1, 0, 2, } },
585     { 2,  121,  121, codebook23, 1,    -5.0,   1.0, (const uint8_t[]){ 5, 4, 6, 3, 7, 2, 8, 1, 9, 0, 10, } },
586     { 2,  169,  169, codebook24, 1,   -30.0,   5.0, (const uint8_t[]){ 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12, } },
587     { 2,   25,   25, codebook25, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },
588     { 2,  169,  169, codebook26, 1, -1530.0, 255.0, (const uint8_t[]){ 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12, } },
589     { 2,  225,  225, codebook27, 1,  -119.0,  17.0, (const uint8_t[]){ 7, 6, 8, 5, 9, 4, 10, 3, 11, 2, 12, 1, 13, 0, 14, } },
590     { 2,  289,  289, codebook28, 1,    -8.0,   1.0, (const uint8_t[]){ 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, 0, 16, } },
591 };
592
593 static inline void init_put_bits(PutBitContext * pb, uint8_t * buf, int buffer_len) {
594     pb->total = buffer_len * 8;
595     pb->total_pos = 0;
596     pb->pos = 0;
597     pb->buf_ptr = buf;
598 }
599
600 static void put_bits(PutBitContext * pb, int bits, uint64_t val) {
601     if ((pb->total_pos += bits) >= pb->total) return;
602     if (!bits) return;
603     if (pb->pos) {
604         if (pb->pos > bits) {
605             *pb->buf_ptr |= val << (8 - pb->pos);
606             pb->pos -= bits;
607             bits = 0;
608         } else {
609             *pb->buf_ptr++ |= (val << (8 - pb->pos)) & 0xFF;
610             val >>= pb->pos;
611             bits -= pb->pos;
612             pb->pos = 0;
613         }
614     }
615     for (; bits >= 8; bits -= 8) {
616         *pb->buf_ptr++ = val & 0xFF;
617         val >>= 8;
618     }
619     if (bits) {
620         *pb->buf_ptr = val;
621         pb->pos = 8 - bits;
622     }
623 }
624
625 static inline void flush_put_bits(PutBitContext * pb) {
626 }
627
628 static inline int put_bits_count(PutBitContext * pb) {
629     return pb->total_pos;
630 }
631
632 static inline void put_codeword(PutBitContext * pb, codebook_t * cb, int entry) {
633     assert(entry >= 0);
634     assert(entry < cb->nentries);
635     assert(cb->lens[entry]);
636     put_bits(pb, cb->lens[entry], cb->codewords[entry]);
637 }
638
639 static int cb_lookup_vals(int lookup, int dimentions, int entries) {
640     if (lookup == 1) return ff_vorbis_nth_root(entries, dimentions);
641     else if (lookup == 2) return dimentions * entries;
642     return 0;
643 }
644
645 static void ready_codebook(codebook_t * cb) {
646     int i;
647
648     ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries);
649
650     if (!cb->lookup) cb->pow2 = cb->dimentions = NULL;
651     else {
652         int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);
653         cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions);
654         cb->pow2 = av_mallocz(sizeof(float) * cb->nentries);
655         for (i = 0; i < cb->nentries; i++) {
656             float last = 0;
657             int j;
658             int div = 1;
659             for (j = 0; j < cb->ndimentions; j++) {
660                 int off;
661                 if (cb->lookup == 1) off = (i / div) % vals; // lookup type 1
662                 else off = i * cb->ndimentions + j; // lookup type 2
663
664                 cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta;
665                 if (cb->seq_p) last = cb->dimentions[i * cb->ndimentions + j];
666                 cb->pow2[i] += cb->dimentions[i * cb->ndimentions + j]*cb->dimentions[i * cb->ndimentions + j];
667                 div *= vals;
668             }
669             cb->pow2[i] /= 2.;
670         }
671     }
672
673 }
674
675 static void ready_residue(residue_t * rc, venc_context_t * venc) {
676     int i;
677     assert(rc->type == 2);
678     rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications);
679     for (i = 0; i < rc->classifications; i++) {
680         int j;
681         codebook_t * cb;
682         for (j = 0; j < 8; j++) if (rc->books[i][j] != -1) break;
683         if (j == 8) continue; // zero
684         cb = &venc->codebooks[rc->books[i][j]];
685         assert(cb->ndimentions >= 2);
686         assert(cb->lookup);
687
688         for (j = 0; j < cb->nentries; j++) {
689             float a;
690             if (!cb->lens[j]) continue;
691             a = fabs(cb->dimentions[j * cb->ndimentions]);
692             if (a > rc->maxes[i][0]) rc->maxes[i][0] = a;
693             a = fabs(cb->dimentions[j * cb->ndimentions + 1]);
694             if (a > rc->maxes[i][1]) rc->maxes[i][1] = a;
695         }
696     }
697     // small bias
698     for (i = 0; i < rc->classifications; i++) {
699         rc->maxes[i][0] += 0.8;
700         rc->maxes[i][1] += 0.8;
701     }
702 }
703
704 static const struct {
705     int dim;
706     int subclass;
707     int masterbook;
708     const int * nbooks;
709 } floor_classes[] = {
710     { 3, 0, 0, (const int[]){  4             } },
711     { 4, 1, 0, (const int[]){  5,  6         } },
712     { 3, 1, 1, (const int[]){  7,  8         } },
713     { 4, 2, 2, (const int[]){ -1,  9, 10, 11 } },
714     { 3, 2, 3, (const int[]){ -1, 12, 13, 14 } },
715 };
716
717 static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccontext) {
718     floor_t * fc;
719     residue_t * rc;
720     mapping_t * mc;
721     int i, book;
722
723     venc->channels = avccontext->channels;
724     venc->sample_rate = avccontext->sample_rate;
725     venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11;
726
727     venc->ncodebooks = sizeof(cvectors)/sizeof(cvectors[0]);
728     venc->codebooks = av_malloc(sizeof(codebook_t) * venc->ncodebooks);
729
730     // codebook 0..14 - floor1 book, values 0..255
731     // codebook 15 residue masterbook
732     // codebook 16..29 residue
733     for (book = 0; book < venc->ncodebooks; book++) {
734         codebook_t * cb = &venc->codebooks[book];
735         int vals;
736         cb->ndimentions = cvectors[book].dim;
737         cb->nentries = cvectors[book].real_len;
738         cb->min = cvectors[book].min;
739         cb->delta = cvectors[book].delta;
740         cb->lookup = cvectors[book].lookup;
741         cb->seq_p = 0;
742
743         cb->lens = av_malloc(sizeof(uint8_t) * cb->nentries);
744         cb->codewords = av_malloc(sizeof(uint32_t) * cb->nentries);
745         memcpy(cb->lens, cvectors[book].clens, cvectors[book].len);
746         memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len);
747
748         if (cb->lookup) {
749             vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);
750             cb->quantlist = av_malloc(sizeof(int) * vals);
751             for (i = 0; i < vals; i++) cb->quantlist[i] = cvectors[book].quant[i];
752         } else {
753             cb->quantlist = NULL;
754         }
755         ready_codebook(cb);
756     }
757
758     venc->nfloors = 1;
759     venc->floors = av_malloc(sizeof(floor_t) * venc->nfloors);
760
761     // just 1 floor
762     fc = &venc->floors[0];
763     fc->partitions = 8;
764     fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions);
765     fc->nclasses = 0;
766     for (i = 0; i < fc->partitions; i++) {
767         static const int a[] = {0,1,2,2,3,3,4,4};
768         fc->partition_to_class[i] = a[i];
769         fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]);
770     }
771     fc->nclasses++;
772     fc->classes = av_malloc(sizeof(floor_class_t) * fc->nclasses);
773     for (i = 0; i < fc->nclasses; i++) {
774         floor_class_t * c = &fc->classes[i];
775         int j, books;
776         c->dim = floor_classes[i].dim;
777         c->subclass = floor_classes[i].subclass;
778         c->masterbook = floor_classes[i].masterbook;
779         books = (1 << c->subclass);
780         c->books = av_malloc(sizeof(int) * books);
781         for (j = 0; j < books; j++) c->books[j] = floor_classes[i].nbooks[j];
782     }
783     fc->multiplier = 2;
784     fc->rangebits = venc->log2_blocksize[0] - 1;
785
786     fc->values = 2;
787     for (i = 0; i < fc->partitions; i++)
788         fc->values += fc->classes[fc->partition_to_class[i]].dim;
789
790     fc->list = av_malloc(sizeof(floor1_entry_t) * fc->values);
791     fc->list[0].x = 0;
792     fc->list[1].x = 1 << fc->rangebits;
793     for (i = 2; i < fc->values; i++) {
794         static const int a[] = {
795              93, 23,372,  6, 46,186,750, 14, 33, 65,
796             130,260,556,  3, 10, 18, 28, 39, 55, 79,
797             111,158,220,312,464,650,850
798         };
799         fc->list[i].x = a[i - 2];
800     }
801     ff_vorbis_ready_floor1_list(fc->list, fc->values);
802
803     venc->nresidues = 1;
804     venc->residues = av_malloc(sizeof(residue_t) * venc->nresidues);
805
806     // single residue
807     rc = &venc->residues[0];
808     rc->type = 2;
809     rc->begin = 0;
810     rc->end = 1600;
811     rc->partition_size = 32;
812     rc->classifications = 10;
813     rc->classbook = 15;
814     rc->books = av_malloc(sizeof(*rc->books) * rc->classifications);
815     {
816         static const int8_t a[10][8] = {
817             { -1, -1, -1, -1, -1, -1, -1, -1, },
818             { -1, -1, 16, -1, -1, -1, -1, -1, },
819             { -1, -1, 17, -1, -1, -1, -1, -1, },
820             { -1, -1, 18, -1, -1, -1, -1, -1, },
821             { -1, -1, 19, -1, -1, -1, -1, -1, },
822             { -1, -1, 20, -1, -1, -1, -1, -1, },
823             { -1, -1, 21, -1, -1, -1, -1, -1, },
824             { 22, 23, -1, -1, -1, -1, -1, -1, },
825             { 24, 25, -1, -1, -1, -1, -1, -1, },
826             { 26, 27, 28, -1, -1, -1, -1, -1, },
827         };
828         memcpy(rc->books, a, sizeof a);
829     }
830     ready_residue(rc, venc);
831
832     venc->nmappings = 1;
833     venc->mappings = av_malloc(sizeof(mapping_t) * venc->nmappings);
834
835     // single mapping
836     mc = &venc->mappings[0];
837     mc->submaps = 1;
838     mc->mux = av_malloc(sizeof(int) * venc->channels);
839     for (i = 0; i < venc->channels; i++) mc->mux[i] = 0;
840     mc->floor = av_malloc(sizeof(int) * mc->submaps);
841     mc->residue = av_malloc(sizeof(int) * mc->submaps);
842     for (i = 0; i < mc->submaps; i++) {
843         mc->floor[i] = 0;
844         mc->residue[i] = 0;
845     }
846     mc->coupling_steps = venc->channels == 2 ? 1 : 0;
847     mc->magnitude = av_malloc(sizeof(int) * mc->coupling_steps);
848     mc->angle = av_malloc(sizeof(int) * mc->coupling_steps);
849     if (mc->coupling_steps) {
850         mc->magnitude[0] = 0;
851         mc->angle[0] = 1;
852     }
853
854     venc->nmodes = 1;
855     venc->modes = av_malloc(sizeof(vorbis_mode_t) * venc->nmodes);
856
857     // single mode
858     venc->modes[0].blockflag = 0;
859     venc->modes[0].mapping = 0;
860
861     venc->have_saved = 0;
862     venc->saved = av_malloc(sizeof(float) * venc->channels * (1 << venc->log2_blocksize[1]) / 2);
863     venc->samples = av_malloc(sizeof(float) * venc->channels * (1 << venc->log2_blocksize[1]));
864     venc->floor = av_malloc(sizeof(float) * venc->channels * (1 << venc->log2_blocksize[1]) / 2);
865     venc->coeffs = av_malloc(sizeof(float) * venc->channels * (1 << venc->log2_blocksize[1]) / 2);
866
867     venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6];
868     venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6];
869
870     ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0);
871     ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0);
872 }
873
874 static void put_float(PutBitContext * pb, float f) {
875     int exp, mant;
876     uint32_t res = 0;
877     mant = (int)ldexp(frexp(f, &exp), 20);
878     exp += 788 - 20;
879     if (mant < 0) { res |= (1 << 31); mant = -mant; }
880     res |= mant | (exp << 21);
881     put_bits(pb, 32, res);
882 }
883
884 static void put_codebook_header(PutBitContext * pb, codebook_t * cb) {
885     int i;
886     int ordered = 0;
887
888     put_bits(pb, 24, 0x564342); //magic
889     put_bits(pb, 16, cb->ndimentions);
890     put_bits(pb, 24, cb->nentries);
891
892     for (i = 1; i < cb->nentries; i++) if (cb->lens[i] < cb->lens[i-1]) break;
893     if (i == cb->nentries) ordered = 1;
894
895     put_bits(pb, 1, ordered);
896     if (ordered) {
897         int len = cb->lens[0];
898         put_bits(pb, 5, len - 1);
899         i = 0;
900         while (i < cb->nentries) {
901             int j;
902             for (j = 0; j+i < cb->nentries; j++) if (cb->lens[j+i] != len) break;
903             put_bits(pb, ilog(cb->nentries - i), j);
904             i += j;
905             len++;
906         }
907     } else {
908         int sparse = 0;
909         for (i = 0; i < cb->nentries; i++) if (!cb->lens[i]) break;
910         if (i != cb->nentries) sparse = 1;
911         put_bits(pb, 1, sparse);
912
913         for (i = 0; i < cb->nentries; i++) {
914             if (sparse) put_bits(pb, 1, !!cb->lens[i]);
915             if (cb->lens[i]) put_bits(pb, 5, cb->lens[i] - 1);
916         }
917     }
918
919     put_bits(pb, 4, cb->lookup);
920     if (cb->lookup) {
921         int tmp = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);
922         int bits = ilog(cb->quantlist[0]);
923
924         for (i = 1; i < tmp; i++) bits = FFMAX(bits, ilog(cb->quantlist[i]));
925
926         put_float(pb, cb->min);
927         put_float(pb, cb->delta);
928
929         put_bits(pb, 4, bits - 1);
930         put_bits(pb, 1, cb->seq_p);
931
932         for (i = 0; i < tmp; i++) put_bits(pb, bits, cb->quantlist[i]);
933     }
934 }
935
936 static void put_floor_header(PutBitContext * pb, floor_t * fc) {
937     int i;
938
939     put_bits(pb, 16, 1); // type, only floor1 is supported
940
941     put_bits(pb, 5, fc->partitions);
942
943     for (i = 0; i < fc->partitions; i++) put_bits(pb, 4, fc->partition_to_class[i]);
944
945     for (i = 0; i < fc->nclasses; i++) {
946         int j, books;
947
948         put_bits(pb, 3, fc->classes[i].dim - 1);
949         put_bits(pb, 2, fc->classes[i].subclass);
950
951         if (fc->classes[i].subclass) put_bits(pb, 8, fc->classes[i].masterbook);
952
953         books = (1 << fc->classes[i].subclass);
954
955         for (j = 0; j < books; j++) put_bits(pb, 8, fc->classes[i].books[j] + 1);
956     }
957
958     put_bits(pb, 2, fc->multiplier - 1);
959     put_bits(pb, 4, fc->rangebits);
960
961     for (i = 2; i < fc->values; i++) put_bits(pb, fc->rangebits, fc->list[i].x);
962 }
963
964 static void put_residue_header(PutBitContext * pb, residue_t * rc) {
965     int i;
966
967     put_bits(pb, 16, rc->type);
968
969     put_bits(pb, 24, rc->begin);
970     put_bits(pb, 24, rc->end);
971     put_bits(pb, 24, rc->partition_size - 1);
972     put_bits(pb, 6, rc->classifications - 1);
973     put_bits(pb, 8, rc->classbook);
974
975     for (i = 0; i < rc->classifications; i++) {
976         int j, tmp = 0;
977         for (j = 0; j < 8; j++) tmp |= (rc->books[i][j] != -1) << j;
978
979         put_bits(pb, 3, tmp & 7);
980         put_bits(pb, 1, tmp > 7);
981
982         if (tmp > 7) put_bits(pb, 5, tmp >> 3);
983     }
984
985     for (i = 0; i < rc->classifications; i++) {
986         int j;
987         for (j = 0; j < 8; j++)
988             if (rc->books[i][j] != -1)
989                 put_bits(pb, 8, rc->books[i][j]);
990     }
991 }
992
993 static int put_main_header(venc_context_t * venc, uint8_t ** out) {
994     int i;
995     PutBitContext pb;
996     uint8_t buffer[50000] = {0}, * p = buffer;
997     int buffer_len = sizeof buffer;
998     int len, hlens[3];
999
1000     // identification header
1001     init_put_bits(&pb, p, buffer_len);
1002     put_bits(&pb, 8, 1); //magic
1003     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);
1004     put_bits(&pb, 32, 0); // version
1005     put_bits(&pb, 8, venc->channels);
1006     put_bits(&pb, 32, venc->sample_rate);
1007     put_bits(&pb, 32, 0); // bitrate
1008     put_bits(&pb, 32, 0); // bitrate
1009     put_bits(&pb, 32, 0); // bitrate
1010     put_bits(&pb, 4, venc->log2_blocksize[0]);
1011     put_bits(&pb, 4, venc->log2_blocksize[1]);
1012     put_bits(&pb, 1, 1); // framing
1013
1014     flush_put_bits(&pb);
1015     hlens[0] = (put_bits_count(&pb) + 7) / 8;
1016     buffer_len -= hlens[0];
1017     p += hlens[0];
1018
1019     // comment header
1020     init_put_bits(&pb, p, buffer_len);
1021     put_bits(&pb, 8, 3); //magic
1022     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);
1023     put_bits(&pb, 32, 0); // vendor length TODO
1024     put_bits(&pb, 32, 0); // amount of comments
1025     put_bits(&pb, 1, 1); // framing
1026
1027     flush_put_bits(&pb);
1028     hlens[1] = (put_bits_count(&pb) + 7) / 8;
1029     buffer_len -= hlens[1];
1030     p += hlens[1];
1031
1032     // setup header
1033     init_put_bits(&pb, p, buffer_len);
1034     put_bits(&pb, 8, 5); //magic
1035     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);
1036
1037     // codebooks
1038     put_bits(&pb, 8, venc->ncodebooks - 1);
1039     for (i = 0; i < venc->ncodebooks; i++) put_codebook_header(&pb, &venc->codebooks[i]);
1040
1041     // time domain, reserved, zero
1042     put_bits(&pb, 6, 0);
1043     put_bits(&pb, 16, 0);
1044
1045     // floors
1046     put_bits(&pb, 6, venc->nfloors - 1);
1047     for (i = 0; i < venc->nfloors; i++) put_floor_header(&pb, &venc->floors[i]);
1048
1049     // residues
1050     put_bits(&pb, 6, venc->nresidues - 1);
1051     for (i = 0; i < venc->nresidues; i++) put_residue_header(&pb, &venc->residues[i]);
1052
1053     // mappings
1054     put_bits(&pb, 6, venc->nmappings - 1);
1055     for (i = 0; i < venc->nmappings; i++) {
1056         mapping_t * mc = &venc->mappings[i];
1057         int j;
1058         put_bits(&pb, 16, 0); // mapping type
1059
1060         put_bits(&pb, 1, mc->submaps > 1);
1061         if (mc->submaps > 1) put_bits(&pb, 4, mc->submaps - 1);
1062
1063         put_bits(&pb, 1, !!mc->coupling_steps);
1064         if (mc->coupling_steps) {
1065             put_bits(&pb, 8, mc->coupling_steps - 1);
1066             for (j = 0; j < mc->coupling_steps; j++) {
1067                 put_bits(&pb, ilog(venc->channels - 1), mc->magnitude[j]);
1068                 put_bits(&pb, ilog(venc->channels - 1), mc->angle[j]);
1069             }
1070         }
1071
1072         put_bits(&pb, 2, 0); // reserved
1073
1074         if (mc->submaps > 1) for (j = 0; j < venc->channels; j++) put_bits(&pb, 4, mc->mux[j]);
1075
1076         for (j = 0; j < mc->submaps; j++) {
1077             put_bits(&pb, 8, 0); // reserved time configuration
1078             put_bits(&pb, 8, mc->floor[j]);
1079             put_bits(&pb, 8, mc->residue[j]);
1080         }
1081     }
1082
1083     // modes
1084     put_bits(&pb, 6, venc->nmodes - 1);
1085     for (i = 0; i < venc->nmodes; i++) {
1086         put_bits(&pb, 1, venc->modes[i].blockflag);
1087         put_bits(&pb, 16, 0); // reserved window type
1088         put_bits(&pb, 16, 0); // reserved transform type
1089         put_bits(&pb, 8, venc->modes[i].mapping);
1090     }
1091
1092     put_bits(&pb, 1, 1); // framing
1093
1094     flush_put_bits(&pb);
1095     hlens[2] = (put_bits_count(&pb) + 7) / 8;
1096
1097     len = hlens[0] + hlens[1] + hlens[2];
1098     p = *out = av_mallocz(64 + len + len/255);
1099
1100     *p++ = 2;
1101     p += av_xiphlacing(p, hlens[0]);
1102     p += av_xiphlacing(p, hlens[1]);
1103     buffer_len = 0;
1104     for (i = 0; i < 3; i++) {
1105         memcpy(p, buffer + buffer_len, hlens[i]);
1106         p += hlens[i];
1107         buffer_len += hlens[i];
1108     }
1109
1110     return p - *out;
1111 }
1112
1113 static float get_floor_average(floor_t * fc, float * coeffs, int i) {
1114     int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x;
1115     int end   = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x;
1116     int j;
1117     float average = 0;
1118
1119     for (j = begin; j < end; j++) average += fabs(coeffs[j]);
1120     return average / (end - begin);
1121 }
1122
1123 static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, uint_fast16_t * posts, int samples) {
1124     int range = 255 / fc->multiplier + 1;
1125     int i;
1126     float tot_average = 0.;
1127     float averages[fc->values];
1128     for (i = 0; i < fc->values; i++) tot_average += averages[i] = get_floor_average(fc, coeffs, i);
1129     tot_average /= fc->values;
1130     tot_average /= venc->quality;
1131
1132     for (i = 0; i < fc->values; i++) {
1133         int position = fc->list[fc->list[i].sort].x;
1134         float average = averages[i];
1135         int j;
1136
1137         average *= pow(tot_average / average, 0.5) * pow(1.25, position/200.); // MAGIC!
1138         for (j = 0; j < range - 1; j++) if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) break;
1139         posts[fc->list[i].sort] = j;
1140     }
1141 }
1142
1143 static int render_point(int x0, int y0, int x1, int y1, int x) {
1144     return y0 +  (x - x0) * (y1 - y0) / (x1 - x0);
1145 }
1146
1147 static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, uint_fast16_t * posts, float * floor, int samples) {
1148     int range = 255 / fc->multiplier + 1;
1149     int coded[fc->values]; // first 2 values are unused
1150     int i, counter;
1151
1152     put_bits(pb, 1, 1); // non zero
1153     put_bits(pb, ilog(range - 1), posts[0]);
1154     put_bits(pb, ilog(range - 1), posts[1]);
1155     coded[0] = coded[1] = 1;
1156
1157     for (i = 2; i < fc->values; i++) {
1158         int predicted = render_point(fc->list[fc->list[i].low].x,
1159                                      posts[fc->list[i].low],
1160                                      fc->list[fc->list[i].high].x,
1161                                      posts[fc->list[i].high],
1162                                      fc->list[i].x);
1163         int highroom = range - predicted;
1164         int lowroom = predicted;
1165         int room = FFMIN(highroom, lowroom);
1166         if (predicted == posts[i]) {
1167             coded[i] = 0; // must be used later as flag!
1168             continue;
1169         } else {
1170             if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1;
1171             if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1;
1172         }
1173         if (posts[i] > predicted) {
1174             if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom;
1175             else coded[i] = (posts[i] - predicted) << 1;
1176         } else {
1177             if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1;
1178             else coded[i] = ((predicted - posts[i]) << 1) - 1;
1179         }
1180     }
1181
1182     counter = 2;
1183     for (i = 0; i < fc->partitions; i++) {
1184         floor_class_t * c = &fc->classes[fc->partition_to_class[i]];
1185         int k, cval = 0, csub = 1<<c->subclass;
1186         if (c->subclass) {
1187             codebook_t * book = &venc->codebooks[c->masterbook];
1188             int cshift = 0;
1189             for (k = 0; k < c->dim; k++) {
1190                 int l;
1191                 for (l = 0; l < csub; l++) {
1192                     int maxval = 1;
1193                     if (c->books[l] != -1) maxval = venc->codebooks[c->books[l]].nentries;
1194                     // coded could be -1, but this still works, cause thats 0
1195                     if (coded[counter + k] < maxval) break;
1196                 }
1197                 assert(l != csub);
1198                 cval |= l << cshift;
1199                 cshift += c->subclass;
1200             }
1201             put_codeword(pb, book, cval);
1202         }
1203         for (k = 0; k < c->dim; k++) {
1204             int book = c->books[cval & (csub-1)];
1205             int entry = coded[counter++];
1206             cval >>= c->subclass;
1207             if (book == -1) continue;
1208             if (entry == -1) entry = 0;
1209             put_codeword(pb, &venc->codebooks[book], entry);
1210         }
1211     }
1212
1213     ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded, fc->multiplier, floor, samples);
1214 }
1215
1216 static float * put_vector(codebook_t * book, PutBitContext * pb, float * num) {
1217     int i, entry = -1;
1218     float distance = FLT_MAX;
1219     assert(book->dimentions);
1220     for (i = 0; i < book->nentries; i++) {
1221         float * vec = book->dimentions + i * book->ndimentions, d = book->pow2[i];
1222         int j;
1223         if (!book->lens[i]) continue;
1224         for (j = 0; j < book->ndimentions; j++) d -= vec[j] * num[j];
1225         if (distance > d) {
1226             entry = i;
1227             distance = d;
1228         }
1229     }
1230     put_codeword(pb, book, entry);
1231     return &book->dimentions[entry * book->ndimentions];
1232 }
1233
1234 static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext * pb, float * coeffs, int samples, int real_ch) {
1235     int pass, i, j, p, k;
1236     int psize = rc->partition_size;
1237     int partitions = (rc->end - rc->begin) / psize;
1238     int channels = (rc->type == 2) ? 1 : real_ch;
1239     int classes[channels][partitions];
1240     int classwords = venc->codebooks[rc->classbook].ndimentions;
1241
1242     assert(rc->type == 2);
1243     assert(real_ch == 2);
1244     for (p = 0; p < partitions; p++) {
1245         float max1 = 0., max2 = 0.;
1246         int s = rc->begin + p * psize;
1247         for (k = s; k < s + psize; k += 2) {
1248             max1 = FFMAX(max1, fabs(coeffs[          k / real_ch]));
1249             max2 = FFMAX(max2, fabs(coeffs[samples + k / real_ch]));
1250         }
1251
1252         for (i = 0; i < rc->classifications - 1; i++) {
1253             if (max1 < rc->maxes[i][0] && max2 < rc->maxes[i][1]) break;
1254         }
1255         classes[0][p] = i;
1256     }
1257
1258     for (pass = 0; pass < 8; pass++) {
1259         p = 0;
1260         while (p < partitions) {
1261             if (pass == 0) for (j = 0; j < channels; j++) {
1262                 codebook_t * book = &venc->codebooks[rc->classbook];
1263                 int entry = 0;
1264                 for (i = 0; i < classwords; i++) {
1265                     entry *= rc->classifications;
1266                     entry += classes[j][p + i];
1267                 }
1268                 put_codeword(pb, book, entry);
1269             }
1270             for (i = 0; i < classwords && p < partitions; i++, p++) {
1271                 for (j = 0; j < channels; j++) {
1272                     int nbook = rc->books[classes[j][p]][pass];
1273                     codebook_t * book = &venc->codebooks[nbook];
1274                     float * buf = coeffs + samples*j + rc->begin + p*psize;
1275                     if (nbook == -1) continue;
1276
1277                     assert(rc->type == 0 || rc->type == 2);
1278                     assert(!(psize % book->ndimentions));
1279
1280                     if (rc->type == 0) {
1281                         for (k = 0; k < psize; k += book->ndimentions) {
1282                             float * a = put_vector(book, pb, &buf[k]);
1283                             int l;
1284                             for (l = 0; l < book->ndimentions; l++) buf[k + l] -= a[l];
1285                         }
1286                     } else {
1287                         int s = rc->begin + p * psize, a1, b1;
1288                         a1 = (s % real_ch) * samples;
1289                         b1 =  s / real_ch;
1290                         s = real_ch * samples;
1291                         for (k = 0; k < psize; k += book->ndimentions) {
1292                             int dim, a2 = a1, b2 = b1;
1293                             float vec[book->ndimentions], * pv = vec;
1294                             for (dim = book->ndimentions; dim--; ) {
1295                                 *pv++ = coeffs[a2 + b2];
1296                                 if ((a2 += samples) == s) { a2=0; b2++; }
1297                             }
1298                             pv = put_vector(book, pb, vec);
1299                             for (dim = book->ndimentions; dim--; ) {
1300                                 coeffs[a1 + b1] -= *pv++;
1301                                 if ((a1 += samples) == s) { a1=0; b1++; }
1302                             }
1303                         }
1304                     }
1305                 }
1306             }
1307         }
1308     }
1309 }
1310
1311 static int apply_window_and_mdct(venc_context_t * venc, signed short * audio, int samples) {
1312     int i, j, channel;
1313     const float * win = venc->win[0];
1314     int window_len = 1 << (venc->log2_blocksize[0] - 1);
1315     float n = (float)(1 << venc->log2_blocksize[0]) / 4.;
1316     // FIXME use dsp
1317
1318     if (!venc->have_saved && !samples) return 0;
1319
1320     if (venc->have_saved) {
1321         for (channel = 0; channel < venc->channels; channel++) {
1322             memcpy(venc->samples + channel*window_len*2, venc->saved + channel*window_len, sizeof(float)*window_len);
1323         }
1324     } else {
1325         for (channel = 0; channel < venc->channels; channel++) {
1326             memset(venc->samples + channel*window_len*2, 0, sizeof(float)*window_len);
1327         }
1328     }
1329
1330     if (samples) {
1331         for (channel = 0; channel < venc->channels; channel++) {
1332             float * offset = venc->samples + channel*window_len*2 + window_len;
1333             j = channel;
1334             for (i = 0; i < samples; i++, j += venc->channels)
1335                 offset[i] = audio[j] / 32768. / n * win[window_len - i - 1];
1336         }
1337     } else {
1338         for (channel = 0; channel < venc->channels; channel++) {
1339             memset(venc->samples + channel*window_len*2 + window_len, 0, sizeof(float)*window_len);
1340         }
1341     }
1342
1343     for (channel = 0; channel < venc->channels; channel++) {
1344         ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel*window_len, venc->samples + channel*window_len*2, venc->floor/*tmp*/);
1345     }
1346
1347     if (samples) {
1348         for (channel = 0; channel < venc->channels; channel++) {
1349             float * offset = venc->saved + channel*window_len;
1350             j = channel;
1351             for (i = 0; i < samples; i++, j += venc->channels)
1352                 offset[i] = audio[j] / 32768. / n * win[i];
1353         }
1354         venc->have_saved = 1;
1355     } else {
1356         venc->have_saved = 0;
1357     }
1358     return 1;
1359 }
1360
1361 static int vorbis_encode_init(AVCodecContext * avccontext)
1362 {
1363     venc_context_t * venc = avccontext->priv_data;
1364
1365     if (avccontext->channels != 2) {
1366         av_log(avccontext, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
1367         return -1;
1368     }
1369
1370     create_vorbis_context(venc, avccontext);
1371
1372     if (avccontext->flags & CODEC_FLAG_QSCALE) venc->quality = avccontext->global_quality / (float)FF_QP2LAMBDA / 10.;
1373     else venc->quality = 1.;
1374     venc->quality *= venc->quality;
1375
1376     avccontext->extradata_size = put_main_header(venc, (uint8_t**)&avccontext->extradata);
1377
1378     avccontext->frame_size = 1 << (venc->log2_blocksize[0] - 1);
1379
1380     avccontext->coded_frame = avcodec_alloc_frame();
1381     avccontext->coded_frame->key_frame = 1;
1382
1383     return 0;
1384 }
1385
1386 static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * packets, int buf_size, void *data)
1387 {
1388     venc_context_t * venc = avccontext->priv_data;
1389     signed short * audio = data;
1390     int samples = data ? avccontext->frame_size : 0;
1391     vorbis_mode_t * mode;
1392     mapping_t * mapping;
1393     PutBitContext pb;
1394     int i;
1395
1396     if (!apply_window_and_mdct(venc, audio, samples)) return 0;
1397     samples = 1 << (venc->log2_blocksize[0] - 1);
1398
1399     init_put_bits(&pb, packets, buf_size);
1400
1401     put_bits(&pb, 1, 0); // magic bit
1402
1403     put_bits(&pb, ilog(venc->nmodes - 1), 0); // 0 bits, the mode
1404
1405     mode = &venc->modes[0];
1406     mapping = &venc->mappings[mode->mapping];
1407     if (mode->blockflag) {
1408         put_bits(&pb, 1, 0);
1409         put_bits(&pb, 1, 0);
1410     }
1411
1412     for (i = 0; i < venc->channels; i++) {
1413         floor_t * fc = &venc->floors[mapping->floor[mapping->mux[i]]];
1414         uint_fast16_t posts[fc->values];
1415         floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);
1416         floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples);
1417     }
1418
1419     for (i = 0; i < venc->channels * samples; i++) {
1420         venc->coeffs[i] /= venc->floor[i];
1421     }
1422
1423     for (i = 0; i < mapping->coupling_steps; i++) {
1424         float * mag = venc->coeffs + mapping->magnitude[i] * samples;
1425         float * ang = venc->coeffs + mapping->angle[i] * samples;
1426         int j;
1427         for (j = 0; j < samples; j++) {
1428             float a = ang[j];
1429             ang[j] -= mag[j];
1430             if (mag[j] > 0) ang[j] = -ang[j];
1431             if (ang[j] < 0) mag[j] = a;
1432         }
1433     }
1434
1435     residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], &pb, venc->coeffs, samples, venc->channels);
1436
1437     flush_put_bits(&pb);
1438     return (put_bits_count(&pb) + 7) / 8;
1439 }
1440
1441
1442 static int vorbis_encode_close(AVCodecContext * avccontext)
1443 {
1444     venc_context_t * venc = avccontext->priv_data;
1445     int i;
1446
1447     if (venc->codebooks) for (i = 0; i < venc->ncodebooks; i++) {
1448         av_freep(&venc->codebooks[i].lens);
1449         av_freep(&venc->codebooks[i].codewords);
1450         av_freep(&venc->codebooks[i].quantlist);
1451         av_freep(&venc->codebooks[i].dimentions);
1452         av_freep(&venc->codebooks[i].pow2);
1453     }
1454     av_freep(&venc->codebooks);
1455
1456     if (venc->floors) for (i = 0; i < venc->nfloors; i++) {
1457         int j;
1458         av_freep(&venc->floors[i].classes);
1459         if (venc->floors[i].classes)
1460             for (j = 0; j < venc->floors[i].nclasses; j++)
1461                 av_freep(&venc->floors[i].classes[j].books);
1462         av_freep(&venc->floors[i].partition_to_class);
1463         av_freep(&venc->floors[i].list);
1464     }
1465     av_freep(&venc->floors);
1466
1467     if (venc->residues) for (i = 0; i < venc->nresidues; i++) {
1468         av_freep(&venc->residues[i].books);
1469         av_freep(&venc->residues[i].maxes);
1470     }
1471     av_freep(&venc->residues);
1472
1473     if (venc->mappings) for (i = 0; i < venc->nmappings; i++) {
1474         av_freep(&venc->mappings[i].mux);
1475         av_freep(&venc->mappings[i].floor);
1476         av_freep(&venc->mappings[i].residue);
1477     }
1478     av_freep(&venc->mappings);
1479
1480     av_freep(&venc->modes);
1481
1482     av_freep(&venc->saved);
1483     av_freep(&venc->samples);
1484     av_freep(&venc->floor);
1485     av_freep(&venc->coeffs);
1486
1487     ff_mdct_end(&venc->mdct[0]);
1488     ff_mdct_end(&venc->mdct[1]);
1489
1490     av_freep(&avccontext->coded_frame);
1491     av_freep(&avccontext->extradata);
1492
1493     return 0 ;
1494 }
1495
1496 AVCodec vorbis_encoder = {
1497     "vorbis",
1498     CODEC_TYPE_AUDIO,
1499     CODEC_ID_VORBIS,
1500     sizeof(venc_context_t),
1501     vorbis_encode_init,
1502     vorbis_encode_frame,
1503     vorbis_encode_close,
1504     .capabilities= CODEC_CAP_DELAY,
1505 };