added bounding box stubs
[swftools.git] / lib / bladeenc / l3bitstream.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-12-04  Andre Piotrowski
24
25         -       redesigned, reformatted, slightly optimized
26 */
27
28 #include        <stdlib.h>
29 #include        <assert.h>
30
31 #include        "system.h"
32 #include        "common.h"
33
34 #include        "l3psy.h"
35 #include        "loop.h"
36 #include        "formatbitstream2.h"
37 #include        "huffman.h"
38
39 #include        "l3bitstream.h" /* the public interface */
40 #include        "l3bitstream-pvt.h"
41
42
43
44
45
46 static  int                             stereo = 1;
47 static  frame_params    *fr_ps  = NULL;
48
49 static  int                             PartHoldersInitialized = 0;
50
51
52
53 static  BitHolder                      *headerPH;
54 static  BitHolder                     *frameSIPH;
55 static  BitHolder                   *channelSIPH[MAX_CHANNELS];
56 static  BitHolder                  *spectrumSIPH[MAX_GRANULES][MAX_CHANNELS];
57 static  BitHolder                *scaleFactorsPH[MAX_GRANULES][MAX_CHANNELS];
58 static  BitHolder                   *codedDataPH[MAX_GRANULES][MAX_CHANNELS];
59 static  BitHolder                *userSpectrumPH[MAX_GRANULES][MAX_CHANNELS];
60 static  BitHolder               *userFrameDataPH;
61
62
63
64 static  BF_FrameData    sFrameData;
65 static  BF_FrameResults sFrameResults;
66
67
68
69
70
71 /*
72         III_format_bitstream()
73
74         This is called after a frame of audio has been quantized and coded.
75         It will write the encoded audio to the bitstream. Note that
76         from a layer3 encoder's perspective the bit stream is primarily
77         a series of main_data() blocks, with header and side information
78         inserted at the proper locations to maintain framing. (See Figure A.7
79         in the IS).
80 */
81
82 void                                    III_format_bitstream
83 (
84         int                                             bitsPerFrame,
85         frame_params                    *in_fr_ps,
86         int                                             l3_enc[2][2][576],
87         III_side_info_t                 *l3_side,
88         III_scalefac_t                  *scalefac,
89         double                                  (*xr)[2][576],
90         char                                    *ancillary,
91         int                                             ancillary_bits
92 )
93 {
94         int                                             gr, ch, i, mode_gr;
95
96         fr_ps = in_fr_ps;
97         stereo = fr_ps->stereo;
98         mode_gr = 2;
99
100         if (!PartHoldersInitialized)
101         {
102                  headerPH = initBitHolder (&sFrameData.header, 16*2);
103                 frameSIPH = initBitHolder (&sFrameData.frameSI, 4*2);
104
105                 for (ch = 0;  ch < MAX_CHANNELS;  ch++)
106                         channelSIPH[ch] = initBitHolder (&sFrameData.channelSI[ch], 8*2);
107
108                 for (gr = 0;  gr < MAX_GRANULES;  gr++)
109                 {
110                         for (ch = 0;  ch < MAX_CHANNELS;  ch++)
111                         {
112                                   spectrumSIPH[gr][ch] = initBitHolder (&sFrameData.  spectrumSI[gr][ch],  32*2);
113                                 scaleFactorsPH[gr][ch] = initBitHolder (&sFrameData.scaleFactors[gr][ch],  64*2);
114                                    codedDataPH[gr][ch] = initBitHolder (&sFrameData.   codedData[gr][ch], 576*2);
115                                 userSpectrumPH[gr][ch] = initBitHolder (&sFrameData.userSpectrum[gr][ch],   4*2);
116                         }
117                 }
118                 userFrameDataPH = initBitHolder (&sFrameData.userFrameData, 8*2);
119
120                 PartHoldersInitialized = 1;
121         }
122
123 #if 1
124         for (gr = 0;  gr < mode_gr;  gr++)
125         {
126                 for (ch = 0;  ch < stereo;  ch++)
127                 {
128                         int                                             *pi = &l3_enc[gr][ch][0];
129                         double                                  *pr =     &xr[gr][ch][0];
130
131                         for (i = 0;  i < 576;  i++, pr++, pi++)
132                                 if (*pr < 0  &&  *pi > 0)
133                                         *pi *= -1;
134                 }
135         }
136 #endif
137
138         encodeSideInfo (l3_side);
139         encodeMainData (l3_enc, l3_side, scalefac);
140         write_ancillary_data (ancillary, ancillary_bits);
141
142         if (l3_side->resvDrain)
143                 drain_into_ancillary_data (l3_side->resvDrain);
144
145         sFrameData.frameLength = bitsPerFrame;
146         sFrameData.nGranules   = mode_gr;
147         sFrameData.nChannels   = stereo;
148
149         writeFrame (&sFrameData, &sFrameResults);
150
151         /* we set this here -- it will be tested in the next loops iteration */
152         l3_side->main_data_begin = sFrameResults.nextBackPtr;
153 }
154
155
156
157
158
159 void                                    III_FlushBitstream (void)
160 {
161         int                                             gr, ch;
162
163         if (PartHoldersInitialized)
164         {
165                 exitBitHolder (&sFrameData.header);
166                 exitBitHolder (&sFrameData.frameSI);
167
168                 for (ch = 0;  ch < MAX_CHANNELS;  ch++)
169                         exitBitHolder (&sFrameData.channelSI[ch]);
170
171
172                 for (gr = 0;  gr < MAX_GRANULES;  gr++)
173                 {
174                         for (ch = 0;  ch < MAX_CHANNELS;  ch++)
175                         {
176                                 exitBitHolder (&sFrameData.  spectrumSI[gr][ch]);
177                                 exitBitHolder (&sFrameData.scaleFactors[gr][ch]);
178                                 exitBitHolder (&sFrameData.   codedData[gr][ch]);
179                                 exitBitHolder (&sFrameData.userSpectrum[gr][ch]);
180                         }
181                 }
182                 exitBitHolder (&sFrameData.userFrameData);
183
184                 PartHoldersInitialized = 0;
185         }
186
187         /* BF_FlushBitstream (frameData, frameResults); */
188 }
189
190
191
192
193
194 static  unsigned                slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
195 static  unsigned                slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
196
197
198
199
200
201 static  void                    encodeMainData
202 (
203         int                                             l3_enc[2][2][576],
204         III_side_info_t                 *side_info,
205         III_scalefac_t                  *scalefac
206 )
207 {
208         int                                             gr, ch, sfb, b, mode_gr;
209
210         mode_gr = 2;
211
212
213         for (gr = 0;  gr < mode_gr;  gr++)
214                 for (ch = 0;  ch < stereo;  ch++)
215                         scaleFactorsPH[gr][ch]->nrEntries = 0;
216
217
218         for (gr = 0;  gr < mode_gr;  gr++)
219                 for (ch = 0;  ch < stereo;  ch++)
220                         codedDataPH[gr][ch]->nrEntries = 0;
221
222
223         for (gr = 0;  gr < 2;  gr++)
224         {
225                 for (ch = 0;  ch < stereo;  ch++)
226                 {
227                         BitHolder                               *ph = scaleFactorsPH[gr][ch];           
228                         gr_info                                 *cod_info = &side_info->gr[gr].ch[ch].tt;
229                         unsigned                                slen1 = slen1_tab[cod_info->scalefac_compress];
230                         unsigned                                slen2 = slen2_tab[cod_info->scalefac_compress];
231                         int                                             *ix = &l3_enc[gr][ch][0];
232
233                         if (cod_info->window_switching_flag  &&  cod_info->block_type == SHORT_TYPE)
234                         {
235                                 if (cod_info->mixed_block_flag)
236                                 {
237                                         for (sfb = 0;  sfb < 8;  sfb++)
238                                                 addBits (ph, scalefac->l[gr][ch][sfb], slen1);
239
240                                         for (sfb = 3;  sfb < 6;  sfb++)
241                                                 for (b = 0;  b < 3;  b++)
242                                                         addBits (ph, scalefac->s[gr][ch][sfb][b], slen1);
243                                 }
244                                 else
245                                 {
246                                         for (sfb = 0;  sfb < 6;  sfb++)
247                                                 for (b = 0;  b < 3;  b++)
248                                                         addBits (ph, scalefac->s[gr][ch][sfb][b], slen1);
249                                 }
250
251                                 for (sfb = 6;  sfb < 12;  sfb++)
252                                         for (b = 0;  b < 3;  b++)
253                                                 addBits (ph, scalefac->s[gr][ch][sfb][b], slen2);
254                         }
255                         else if (gr == 0)
256                         {
257                                 for (sfb = 0;  sfb < 11;  sfb++)
258                                         addBits (ph, scalefac->l[gr][ch][sfb], slen1);
259
260                                 for (sfb = 11;  sfb < 21;  sfb++)
261                                         addBits (ph, scalefac->l[gr][ch][sfb], slen2);
262                         }
263                         else
264                         {
265                                 if (!side_info->scfsi[ch][0])
266                                         for (sfb = 0;  sfb < 6;  sfb++)
267                                                 addBits (ph, scalefac->l[gr][ch][sfb], slen1);
268
269                                 if (!side_info->scfsi[ch][1])
270                                         for (sfb = 6;  sfb < 11;  sfb++)
271                                                 addBits (ph, scalefac->l[gr][ch][sfb], slen1);
272
273                                 if (!side_info->scfsi[ch][2])
274                                         for (sfb = 11;  sfb < 16;  sfb++)
275                                                 addBits (ph, scalefac->l[gr][ch][sfb], slen2);
276
277                                 if (!side_info->scfsi[ch][3])
278                                         for (sfb = 16;  sfb < 21;  sfb++)
279                                                 addBits (ph, scalefac->l[gr][ch][sfb], slen2);
280                         }
281
282                         Huffmancodebits (codedDataPH[gr][ch], ix, cod_info);
283                 } /* for ch */
284         } /* for gr */
285 } /* main_data */
286
287
288
289
290
291 /*____ encodeSideInfo() _____________________________________________________*/
292
293 static  int                             encodeSideInfo (III_side_info_t *side_info)
294 {
295         int                                             gr, ch, scfsi_band, region, b, bits_sent, mode_gr;
296         layer                                   *info = fr_ps->header;
297
298         mode_gr =  2;
299
300
301         headerPH->nrEntries = 0;
302
303         addBits (headerPH, 0xfff                   , 12);
304         addBits (headerPH, 1                       ,  1);
305         addBits (headerPH, 4 - 3                   ,  2);   /* 4 - Layer */
306         addBits (headerPH, !info->error_protection ,  1);
307         addBits (headerPH, info->bitrate_index     ,  4);
308         addBits (headerPH, info->sampling_frequency,  2);
309         addBits (headerPH, info->padding           ,  1);
310         addBits (headerPH, info->extension         ,  1);
311         addBits (headerPH, info->mode              ,  2);
312         addBits (headerPH, info->mode_ext          ,  2);
313         addBits (headerPH, info->copyright         ,  1);
314         addBits (headerPH, info->original          ,  1);
315         addBits (headerPH, info->emphasis          ,  2);
316
317         bits_sent = 32;
318
319         if (info->error_protection)
320         {
321                 addBits (headerPH, 0, 16);   /* Just a dummy add. Real CRC calculated & inserted in writeSideInfo() */
322                 bits_sent += 16;
323         }
324
325
326         frameSIPH->nrEntries = 0;
327
328         addBits (frameSIPH, side_info->main_data_begin, 9);
329
330         if (stereo == 2)
331                 addBits (frameSIPH, side_info->private_bits, 3);
332         else
333                 addBits (frameSIPH, side_info->private_bits, 5);
334
335
336         for (ch = 0;  ch < stereo;  ch++)
337         {
338                 BitHolder                               *ph = channelSIPH[ch];
339
340                 ph->nrEntries = 0;
341
342                 for (scfsi_band = 0;  scfsi_band < 4;  scfsi_band++)
343                         addBits (ph, side_info->scfsi[ch][scfsi_band], 1);
344         }
345
346
347         for (gr = 0;  gr < 2;  gr++)
348         {
349                 for (ch = 0;  ch < stereo;  ch++)
350                 {
351                         BitHolder                               *ph = spectrumSIPH[gr][ch];
352                         gr_info                                 *cod_info = &side_info->gr[gr].ch[ch].tt;
353
354                         ph->nrEntries = 0;
355
356                         addBits (ph, cod_info->part2_3_length       , 12);
357                         addBits (ph, cod_info->big_values           ,  9);
358                         addBits (ph, cod_info->global_gain          ,  8);
359                         addBits (ph, cod_info->scalefac_compress    ,  4);
360                         addBits (ph, cod_info->window_switching_flag,  1);
361
362                         if (cod_info->window_switching_flag)
363                         {   
364                                 addBits (ph, cod_info->block_type      , 2);
365                                 addBits (ph, cod_info->mixed_block_flag, 1);
366
367                                 for (region = 0; region < 2; region++)
368                                         addBits (ph, cod_info->table_select[region], 5);
369
370                                 for (b = 0;  b < 3;  b++)
371                                         addBits (ph, cod_info->subblock_gain[b], 3);
372                         }
373                         else
374                         {
375                                 for (region = 0; region < 3; region++)
376                                         addBits (ph, cod_info->table_select[region], 5);
377
378                                 addBits (ph, cod_info->region0_count, 4);
379                                 addBits (ph, cod_info->region1_count, 3);
380                         }
381
382                         addBits (ph, cod_info->preflag           , 1);
383                         addBits (ph, cod_info->scalefac_scale    , 1);
384                         addBits (ph, cod_info->count1table_select, 1);
385                 }
386         }
387
388
389         if (stereo == 2)
390                 bits_sent += 256;
391         else
392                 bits_sent += 136;
393
394
395         return bits_sent;
396 }
397
398
399
400
401
402 /*____ write_ancillary_data() _______________________________________________*/
403
404 static  void                    write_ancillary_data
405 (
406         char                                    *theData,
407         int                                             lengthInBits
408 )
409 {
410         int                                             bytesToSend   = lengthInBits / 8;
411         int                                             remainingBits = lengthInBits % 8;
412         unsigned                                wrd;
413
414         userFrameDataPH->nrEntries = 0;
415
416         while (bytesToSend--)
417         {
418                 wrd = *theData++;
419                 addBits (userFrameDataPH, wrd, 8);
420         }
421         if (remainingBits)
422         {
423                 /* right-justify remaining bits */
424                 wrd = *theData >> (8 - remainingBits);
425                 addBits (userFrameDataPH, wrd, remainingBits);
426         }
427 }
428
429
430
431
432
433 /*
434         Some combinations of bitrate, Fs, and stereo make it impossible to stuff
435         out a frame using just main_data, due to the limited number of bits to
436         indicate main_data_length. In these situations, we put stuffing bits into
437         the ancillary data...
438 */
439 static  void                    drain_into_ancillary_data (int lengthInBits)
440 {
441         int                                             wordsToSend   = lengthInBits / 32;
442         int                                             remainingBits = lengthInBits % 32;
443
444         /*
445                 userFrameDataPH->part->nrEntries set by call to write_ancillary_data()
446         */
447
448         while (wordsToSend--)
449                 addBits (userFrameDataPH, 0, 32);
450         if (remainingBits)
451                 addBits (userFrameDataPH, 0, remainingBits); 
452 }
453
454
455
456
457
458 /*
459         Note the discussion of huffmancodebits() on pages 28
460         and 29 of the IS, as well as the definitions of the side
461         information on pages 26 and 27.
462 */
463 static  void                    Huffmancodebits
464 (
465         BitHolder                               *ph,
466         int                                             *ix,
467         gr_info                                 *cod_info
468 )
469 {
470         int                                             sfb, window, line, start, end;
471         int                                             stuffingBits, table;
472
473         int                                             bitsWritten = 0;
474         int                                             bigvalues   = cod_info->big_values * 2;
475
476
477         /*
478                 Within each scalefactor band, data is given for successive time windows,
479                 beginning with window 0 and ending with window 2 (in case of short blocks!
480                 --- there is only one long block window). Within each window, the quantized
481                 values are then arranged in order of increasing frequency...
482         */
483
484         /* 1: Write the bigvalues */
485         if (bigvalues)
486         {
487                 if (cod_info->window_switching_flag  &&  (cod_info->block_type == SHORT_TYPE))
488                 {
489                         int                                                     (*ix_s)[3] = (int (*)[3]) ix;
490                         int                                                     *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].s[0];
491
492                         table = cod_info->table_select[0];
493                         if (table)
494                         {
495                                 if (cod_info->mixed_block_flag)  /* Mixed blocks long, short */
496                                 {
497                                         for (line=0; line<36; line+=2)   /* cod_info->address1 = 36 */
498                                                 bitsWritten += writeHuffmanCode (ph, table, ix[line], ix[line+1]);
499                                 }
500                                 else
501                                 {
502                                         for (sfb=0; sfb<3; sfb++)   /* (cod_info->region0_count + 1) / 3 = 3 */
503                                         {
504                                                 start = scalefac[sfb];
505                                                 end   = scalefac[sfb+1];
506
507                                                 for (window=0; window<3; window++)
508                                                         for (line=start; line<end; line+=2)
509                                                                 bitsWritten += writeHuffmanCode (ph, table, ix_s[line][window], ix_s[line+1][window]);
510                                         }
511                                 }
512                         }
513
514                         table = cod_info->table_select[1];
515                         if (table)
516                         {
517                                 for (sfb=3; sfb<SFB_SMAX; sfb++)   /* scalefac[3] = 12 --- 12*3 = 36 */
518                                 {
519                                         start = scalefac[sfb];
520                                         end   = scalefac[sfb+1]; 
521
522                                         for (window=0; window<3; window++)
523                                                 for (line=start; line<end; line+=2)
524                                                         bitsWritten += writeHuffmanCode (ph, table, ix_s[line][window], ix_s[line+1][window]);
525                                 }
526                         }
527                 }
528                 else   /* Long blocks */
529                 {
530                         int                                                     region1Start = (cod_info->address1 > bigvalues) ? bigvalues : cod_info->address1;
531                         int                                                     region2Start = (cod_info->address2 > bigvalues) ? bigvalues : cod_info->address2;
532
533                         table = cod_info->table_select[0];
534                         if (table)
535                                 for (line=0; line<region1Start; line+=2)
536                                         bitsWritten += writeHuffmanCode (ph, table, ix[line], ix[line+1]);
537
538                         table = cod_info->table_select[1];
539                         if (table)
540                                 for (line=region1Start; line<region2Start; line+=2)
541                                         bitsWritten += writeHuffmanCode (ph, table, ix[line], ix[line+1]);
542
543                         table = cod_info->table_select[2];
544                         if (table)
545                                 for (line=region2Start; line<bigvalues; line+=2)
546                                         bitsWritten += writeHuffmanCode (ph, table, ix[line], ix[line+1]);
547                 }
548         }
549
550         /* 2: Write count1 area */
551         if (cod_info->count1)
552         {
553                 struct huffcodetab              *h = ht + (cod_info->count1table_select + 32);
554
555                 int                                             *pos = ix + bigvalues;
556                 int                                             *end = ix + bigvalues + (cod_info->count1 * 4);
557
558                 while (pos < end)
559                 {
560                         int                                             len, v, w, x, y;
561                         int                                             bits = 0;
562                         int                                             p    = 0;
563
564                         v = *pos++;  if (v)  bits++, p |= 1;
565                         w = *pos++;  if (w)  bits++, p |= 2;
566                         x = *pos++;  if (x)  bits++, p |= 4;
567                         y = *pos++;  if (y)  bits++, p |= 8;
568
569                         addBits (ph, h->table[p], len = h->hlen[p]);
570
571                         if (v)  addBits (ph, v<0, 1);
572                         if (w)  addBits (ph, w<0, 1);
573                         if (x)  addBits (ph, x<0, 1);
574                         if (y)  addBits (ph, y<0, 1);
575
576                         bitsWritten += bits+len;
577                 }
578         }
579
580
581         stuffingBits = cod_info->part2_3_length - cod_info->part2_length - bitsWritten;
582         if (stuffingBits)
583         {
584                 int                                             stuffingWords = stuffingBits / 32;
585                 int                                             remainingBits = stuffingBits % 32;
586
587                 /*
588                         Due to the nature of the Huffman code
589                         tables, we will pad with ones
590                 */
591                 while (stuffingWords--)
592                         addBits (ph, ~0, 32);
593                 if (remainingBits)
594                         addBits (ph, ~0, remainingBits);
595
596                 bitsWritten += stuffingBits;
597         }
598 }
599
600
601
602
603
604 /*
605         Implements the pseudocode of page 98 of the IS
606
607         aaaaaaaaaaaaaaargh --- why don«t write the code immediately?
608 */
609
610 static  int                             writeHuffmanCode
611 (
612         BitHolder                               *ph,
613         int                                             table,
614         int                                             x,
615         int                                             y
616 )
617 {
618         struct huffcodetab              *h = ht + table;
619
620         unsigned                                signx = (x <= 0) ? (x = -x, 1) : 0;
621         unsigned                                signy = (y <= 0) ? (y = -y, 1) : 0;
622
623         unsigned                                code, cbits, idx;
624
625 assert (table);
626 /*
627         if (table == 0)
628                 return 0;
629 */
630
631         if (table > 15)   /* ESC-table is used */
632         {
633                 unsigned                                linbits = h->linbits;
634                 unsigned                                ext     = 0;
635                 unsigned                                xbits   = 0;
636
637                 if (x)  {if (x > 14)  {ext =                    (x-15);  xbits += linbits;  x = 15;}  ext = (ext << 1) | signx;  xbits++;}
638                 if (y)  {if (y > 14)  {ext = (ext << linbits) | (y-15);  xbits += linbits;  y = 15;}  ext = (ext << 1) | signy;  xbits++;}
639
640                 idx   = x * h->ylen + y;
641                 code  = h->table[idx];
642                 cbits = h->hlen[idx];
643
644                 addBits (ph, code, cbits);
645                 addBits (ph, ext , xbits);
646
647                 return cbits + xbits;
648         }
649         else   /* No ESC-words */
650         {
651                 idx   = x * h->ylen + y;
652                 code  = h->table[idx];
653                 cbits = h->hlen[idx];
654
655                 if (x)  {code = (code << 1) | signx;  cbits++;}
656                 if (y)  {code = (code << 1) | signy;  cbits++;}
657
658                 addBits (ph, code, cbits);
659
660                 return cbits;
661         }
662 }
663
664
665