several more bugfixes.
[swftools.git] / lib / bladeenc / codec.c
1 /*
2             (c) Copyright 1998-2000 - Tord Jansson
3             ======================================
4
5         This file is part of the BladeEnc MP3 Encoder, based on
6         ISO's reference code for MPEG Layer 3 compression, and might
7         contain smaller or larger sections that are directly taken
8         from ISO's reference code.
9
10         All changes to the ISO reference code herein are either
11         copyrighted by Tord Jansson (tord.jansson@swipnet.se)
12         or sublicensed to Tord Jansson by a third party.
13
14     BladeEnc is free software; you can redistribute this file
15     and/or modify it under the terms of the GNU Lesser General Public
16     License as published by the Free Software Foundation; either
17     version 2.1 of the License, or (at your option) any later version.
18
19
20
21     ------------    CHANGES    ------------
22
23     2000-11-22  Andre Piotrowski
24
25     -   big fix: module - original dist10 error - l3_sb_sample has to be of type 'L3SBS' not 'SBS'.
26     -   bug fix: codecInit() - don't reset fInit-huffman_read_flag - read_huffcodetab() is a memory eater!
27
28     2000-12-11  ap
29
30     -   reformatted
31     -   speed up: use single buffer
32 */
33
34 #include    <stdlib.h>
35 #include    <assert.h>
36
37 #include    "common.h"
38 #include    "l3psy.h"
39 #include    "mdct.h"
40 #include    "reservoir.h"
41 #include    "formatbitstream2.h"
42 #include    "l3bitstream.h"
43 #include    "loop.h"
44 #include    "encoder.h"
45 #include    "codec.h"
46
47
48
49
50
51 extern  int             fInit_fft;
52
53
54
55
56
57 /************************************************************************/
58
59 #define SAMPLES_PER_FRAME       1152
60
61 static  L3SBS                   l3_sb_sample;
62
63 static  layer                   info;
64
65
66
67 #if ORG_BUFFERS
68 static  short                   buffer[2][1152];
69 /*  static  float                   snr32[32]; */
70 static  short                   sam[2][2048];
71 #else
72 static  FLOAT                   buffer[2][2048];
73 static  int                     buffer_idx;
74 #endif
75
76
77
78 static  int                     whole_SpF;
79
80 static  double                  frac_SpF, slot_lag;
81
82 static  int                     stereo, error_protection;
83
84 static  III_side_info_t         l3_side;
85 static  CodecInitOut            sOut;
86
87 static  frame_params            fr_ps;
88
89
90
91 char                    *pEncodedOutput;
92 int                     outputBit;
93
94 volatile double         avg_slots_per_frame;
95
96
97
98
99
100 /*____ codecInit() ____________________________________________________________*/
101
102 CodecInitOut            *codecInit (CodecInitIn *psIn)
103 {
104     int                     j;
105
106     /* Read psIn */
107
108     switch (psIn->frequency)
109     {
110         case 48000:  info.sampling_frequency = 1;  break;
111         case 44100:  info.sampling_frequency = 0;  break;
112         case 32000:  info.sampling_frequency = 2;  break;
113         default   :  return FALSE;
114     }
115
116     switch (psIn->mode)
117     {
118         case  0:  info.mode = MPG_MD_STEREO      ;  info.mode_ext = 0;  break;
119         case  2:  info.mode = MPG_MD_DUAL_CHANNEL;  info.mode_ext = 0;  break;
120         case  3:  info.mode = MPG_MD_MONO        ;  info.mode_ext = 0;  break;
121         default:  return FALSE;
122     }
123
124     j = 0;
125     while (j < 15  &&  bitratex[1][j] != psIn->bitrate)
126         j++;
127     info.bitrate_index    = j;
128
129     info.version          = 1;   /* Default: MPEG-1 */
130     info.emphasis         = psIn->emphasis;
131     info.extension        = psIn->fPrivate;
132     info.copyright        = psIn->fCopyright;
133     info.original         = psIn->fOriginal;
134     info.error_protection = psIn->fCRC;
135
136
137 /*_______ Static-fix _______________*/
138
139
140     fInit_mdct_sub = 0;
141     fInit_mdct = 0;
142
143     fInit_fft = 0;
144
145     fInit_iteration_loop = 0;
146 /*  DON'T DO THAT ALL THE TIME
147     fInit_huffman_read_flag = 0;
148 */
149
150     fixStatic_loop();
151
152     l3_side.main_data_begin = 0;
153     fixStatic_reservoir();
154
155
156 /*___________________________________*/
157
158     psycho_anal_init (psIn->frequency);
159     initWindowFilterSubband ();
160     initFormatBitstream ();
161
162 /*     clear buffers */
163     memset ((char *) l3_sb_sample, 0, sizeof(l3_sb_sample));
164     memset((char *) buffer, 0, sizeof(buffer));
165 /*    memset((char *) snr32, 0, sizeof(snr32));*/
166 #if ORG_BUFFERS
167     memset((char *) sam, 0, sizeof(sam));
168 #endif
169
170
171
172     fr_ps.header      = &info;
173     fr_ps.tab_num     = -1;   /* no table loaded */
174     fr_ps.alloc       = NULL;
175     fr_ps.actual_mode = info.mode;
176     fr_ps.stereo      = (info.mode == MPG_MD_MONO) ? 1 : 2;
177     fr_ps.sblimit     = SBLIMIT;
178     fr_ps.jsbound     = SBLIMIT;
179
180     
181     stereo = fr_ps.stereo;
182     error_protection = info.error_protection;
183
184     avg_slots_per_frame =
185         ((double) SAMPLES_PER_FRAME / s_freq[1][info.sampling_frequency]) *
186         ((double) bitratex[1][info.bitrate_index] / 8.0);
187     whole_SpF = (int) avg_slots_per_frame;
188     frac_SpF  = avg_slots_per_frame - (double) whole_SpF;
189     slot_lag  = -frac_SpF;
190
191 /*    if (frac_SpF == 0)
192         info.padding = 0;
193 */
194     genNoisePowTab();
195
196 /*________________________*/
197
198
199     if( stereo != 2 )
200         sOut.nSamples = SAMPLES_PER_FRAME;
201     else
202         sOut.nSamples = SAMPLES_PER_FRAME*2;
203
204     sOut.bufferSize = 2048;
205
206     return  &sOut;          /* How many samples we want in each chunk... */
207 }
208
209
210
211
212
213 /*____ codecEncodeChunk() _____________________________________________________*/
214
215 unsigned int            codecEncodeChunk
216 (
217     int                     nSamples,
218     short                   *pSamples,
219     char                    *pDest
220 )
221 {
222     static  double              xr[2][2][576];
223     static  double              xr_dec[2][2][576];
224     static  double              pe[2][2];
225     static  int                 l3_enc[2][2][576];
226     static  III_psy_ratio       ratio;
227     static  III_scalefac_t      scalefac;
228     int                         gr, ch;
229     int                         mean_bits, sideinfo_len;
230     int                         bitsPerFrame;
231     int                         j;
232
233 /*
234     static  int                 fFirst = TRUE;
235
236     if (fFirst)
237     {
238         memset ((char *) &xr      , 0, sizeof(xr));
239         memset ((char *) &xr_dec  , 0, sizeof(xr_dec));
240         memset ((char *) &pe      , 0, sizeof(pe));
241         memset ((char *) &l3_enc  , 0, sizeof(l3_enc));
242         memset ((char *) &ratio   , 0, sizeof(ratio));
243         memset ((char *) &l3_side , 0, sizeof(l3_side));
244         memset ((char *) &scalefac, 0, sizeof(scalefac));
245
246         fFirst = FALSE;
247     }
248 */
249
250
251 /* rebuffer audio */
252
253 #if ORG_BUFFERS
254     rebuffer_audio (buffer, pSamples, nSamples, stereo);
255 #else
256     rebuffer_audio (pSamples, buffer, &buffer_idx, nSamples, stereo);
257 #endif
258
259
260 /* psychoacoustic model */
261
262     for (gr = 0;  gr < 2;  gr++)
263         for (ch = 0;  ch < stereo;  ch++)
264             psycho_anal
265             (
266 #if ORG_BUFFERS
267                 &buffer[ch][gr*576],
268                 &sam[ch][0],
269 #else
270                 buffer[ch],
271                 (buffer_idx+gr*576) & 2047,
272 #endif
273                 ch,
274                 3,
275                 /*snr32,*/
276                 &ratio.l[gr][ch][0],
277                 &ratio.s[gr][ch][0],
278                 &pe[gr][ch],
279                 &l3_side.gr[gr].ch[ch].tt
280             );
281
282
283 /* polyphase filtering */
284
285     for (gr = 0;  gr < 2;  gr++)
286     {
287         int     gr_plus_1 = gr_idx[gr+1];
288
289         for (ch = 0;  ch < stereo;  ch++)
290         {
291             for (j = 0;  j < 18;  j++)
292             {
293                 windowFilterSubband
294                 (
295 #if ORG_BUFFERS
296                     &buffer[ch][gr*18*32+32*j],
297                     ch,
298 #else
299                     buffer[ch],
300                     (buffer_idx+768-480+gr*18*32+32*j) & 2047,
301 #endif
302                     l3_sb_sample[ch][gr_plus_1][j]
303                 );
304             }
305         }
306     }
307
308
309 /* apply mdct to the polyphase outputs */
310
311     mdct_sub (&l3_sb_sample, xr, stereo, &l3_side, 2);
312
313
314     pEncodedOutput = pDest;
315     outputBit = 8;
316     pEncodedOutput[0] = 0;
317
318
319     if (frac_SpF != 0)
320     {
321         if (slot_lag > (frac_SpF-1.0))
322         {
323             slot_lag -= frac_SpF;
324             info.padding = 0;
325         }
326         else
327         {
328             info.padding = 1;
329             slot_lag += (1-frac_SpF);
330         }
331     }
332
333     bitsPerFrame = 8 * whole_SpF + (info.padding * 8);
334
335
336 /* determine the mean bitrate for main data */
337
338     sideinfo_len = 32;
339
340     if (stereo == 1)
341         sideinfo_len += 136;
342     else
343         sideinfo_len += 256;
344
345     if (info.error_protection)
346         sideinfo_len += 16;
347
348     mean_bits = (bitsPerFrame - sideinfo_len) / 2;
349
350
351 /* bit and noise allocation */
352
353     iteration_loop
354     (
355         pe,
356         xr,
357         &ratio,
358         &l3_side,
359         l3_enc,
360         mean_bits,
361         stereo,
362         xr_dec,
363         &scalefac,
364         &fr_ps,
365         0,
366         bitsPerFrame
367     );
368
369
370 /* write the frame to the bitstream */
371
372     III_format_bitstream
373     (
374         bitsPerFrame,
375         &fr_ps,
376         l3_enc,
377         &l3_side,
378         &scalefac,
379         xr,
380         NULL,
381         0
382     );
383
384
385     return  pEncodedOutput - pDest;
386 }
387
388
389
390
391
392 /*____ codecExit() ____________________________________________________________*/
393
394 unsigned int            codecExit (char *pDest)
395 {
396     pEncodedOutput = pDest;
397     outputBit = 8;
398     pEncodedOutput[0] = 0;
399
400     psycho_anal_exit ();
401     exitFormatBitstream ();
402     III_FlushBitstream ();
403
404     return pEncodedOutput - pDest;
405 }
406
407
408
409
410
411 /*____ codecFlush() _________________________________________________________*/
412
413 unsigned int            codecFlush (char *pDest)
414 {
415     pEncodedOutput = pDest;
416     outputBit = 8;
417     pEncodedOutput[0] = 0;
418
419     flushFrame ();
420
421     whole_SpF = (int) avg_slots_per_frame;
422     frac_SpF  = avg_slots_per_frame - (double) whole_SpF;
423     slot_lag  = -frac_SpF;
424
425     l3_side.main_data_begin = 0;
426     fixStatic_reservoir ();
427
428     return pEncodedOutput - pDest;
429 }
430
431
432