2209d85ce21b427a6a52e0cdfd0585b67cd6dfc3
[swftools.git] / lib / modules / swfsound.c
1 /* swfaction.c
2
3    SWF Sound handling routines
4    
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2001, 2002 Matthias Kramm <kramm@quiss.org>
9  
10    This file is distributed under the GPL, see file COPYING for details 
11
12 */
13
14 #ifndef RFXSWF_DISABLESOUND
15
16 #include "../rfxswf.h"
17
18 #ifdef BLADEENC
19 fjokjklj
20 CodecInitOut * init = 0;
21 void swf_SetSoundStreamHead(TAG*tag, U16 avgnumsamples)
22 {
23     U8 playbackrate = 3; // 0 = 5.5 Khz, 1 = 11 Khz, 2 = 22 Khz, 3 = 44 Khz
24     U8 playbacksize = 1; // 0 = 8 bit, 1 = 16 bit
25     U8 playbacktype = 0; // 0 = mono, 1 = stereo
26     U8 compression = 2; // 0 = raw, 1 = ADPCM, 2 = mp3, 3 = raw le, 6 = nellymoser
27     U8 rate = 3; // 0 = 5.5 Khz, 1 = 11 Khz, 2 = 22 Khz, 3 = 44 Khz
28     U8 size = 1; // 0 = 8 bit, 1 = 16 bit
29     U8 type = 0; // 0 = mono, 1 = stereo
30
31     CodecInitIn params;
32     memset(&params, 0, sizeof(params));
33     params.frequency = 44100;  //48000, 44100 or 32000
34     params.mode = 3;      //0 = Stereo, 2 = Dual Channel, 3 = Mono
35     params.emphasis = 0;  //0 = None, 1 = 50/15 microsec, 3 = CCITT J.17
36     params.bitrate = 128;         //default is 128 (64 for mono)
37     init = codecInit(&params);
38
39     swf_SetU8(tag,(playbackrate<<2)|(playbacksize<<1)|playbacktype);
40     swf_SetU8(tag,(compression<<4)|(rate<<2)|(size<<1)|type);
41     swf_SetU16(tag,avgnumsamples);
42
43     printf("numSamples:%d\n",init->nSamples);
44     printf("bufferSize:%d\n",init->bufferSize);
45 }
46
47 void swf_SetSoundStreamBlock(TAG*tag, S16*samples, int numsamples, char first)
48 {
49     char*buf;
50     int len = 0;
51
52     buf = malloc(init->bufferSize);
53     if(!buf)
54         return;
55     
56     len = codecEncodeChunk (numsamples, samples, buf);
57     len += codecFlush (&buf[len]);
58     len += codecExit (&buf[len]);
59
60     if(first) {
61         swf_SetU16(tag, numsamples); // number of samples
62         swf_SetU16(tag, 0); // seek
63     }
64     swf_SetBlock(tag, buf, len);
65     free(buf);
66 }
67 #endif
68
69
70 #ifdef LAME
71
72 #include "../lame/lame.h"
73
74 /* TODO: find a way to set these from the outside */
75 int swf_mp3_samplerate = 44100;
76 int swf_mp3_channels = 1;
77
78 static lame_global_flags*lame_flags;
79
80 static void initlame(unsigned char*buf, int bufsize)
81 {
82     lame_flags = lame_init();
83
84     lame_set_in_samplerate(lame_flags, swf_mp3_samplerate);
85     lame_set_num_channels(lame_flags, swf_mp3_channels);
86     lame_set_scale(lame_flags, 0);
87
88     // MPEG1    32, 44.1,   48khz
89     // MPEG2    16, 22.05,  24
90     // MPEG2.5   8, 11.025, 12
91     // (not used by decoding routines)
92     lame_set_out_samplerate(lame_flags, 11025);
93
94     lame_set_quality(lame_flags, 0);
95     lame_set_mode(lame_flags, MONO/*3*/);
96     //lame_set_compression_ratio(lame_flags, 11.025);
97     lame_set_bWriteVbrTag(lame_flags, 0);
98
99     lame_init_params(lame_flags);
100     lame_init_bitstream(lame_flags);
101
102     /* The first two flush calls to lame always fail, for
103        some reason. Do them here where they cause no damage. */
104     lame_encode_flush_nogap(lame_flags, buf, bufsize);
105     //printf("init:flush_nogap():%d\n", len);
106     lame_encode_flush(lame_flags, buf, bufsize);
107     //printf("init:flush():%d\n", len);
108 }
109
110 void swf_SetSoundStreamHead(TAG*tag, int avgnumsamples)
111 {
112     unsigned char buf[4096];
113     int bufsize = 1152*2;
114     int len;
115     short int samples[1152*2];
116
117     U8 playbackrate = 1; // 0 = 5.5 Khz, 1 = 11 Khz, 2 = 22 Khz, 3 = 44 Khz
118     U8 playbacksize = 1; // 0 = 8 bit, 1 = 16 bit
119     U8 playbacktype = 0; // 0 = mono, 1 = stereo
120     U8 compression = 2; // 0 = raw, 1 = ADPCM, 2 = mp3, 3 = raw le, 6 = nellymoser
121     U8 rate = 1; // 0 = 5.5 Khz, 1 = 11 Khz, 2 = 22 Khz, 3 = 44 Khz
122     U8 size = 1; // 0 = 8 bit, 1 = 16 bit
123     U8 type = 0; // 0 = mono, 1 = stereo
124     
125     memset(samples,0,sizeof(samples));
126
127     initlame(buf, bufsize);
128
129     swf_SetU8(tag,(playbackrate<<2)|(playbacksize<<1)|playbacktype);
130     swf_SetU8(tag,(compression<<4)|(rate<<2)|(size<<1)|type);
131     swf_SetU16(tag,avgnumsamples);
132 }
133
134 void swf_SetSoundStreamBlock(TAG*tag, S16*samples, int seek, char first)
135 {
136     char*buf;
137     int oldlen=0,len = 0;
138     int bufsize = 16384;
139     int numsamples = 1152*2;
140
141     buf = malloc(bufsize);
142     if(!buf)
143         return;
144
145     if(first) {
146         int fs = lame_get_framesize(lame_flags);
147         //printf("framesize:%d\n", fs);
148         swf_SetU16(tag, fs); // samples per mp3 frame
149         swf_SetU16(tag, seek); // seek
150     }
151
152     len += lame_encode_buffer(lame_flags, samples, samples, numsamples, &buf[len], bufsize-len);
153     //printf("block: %d (+%d)\n", len, len-oldlen);
154     oldlen = len;
155
156     len += lame_encode_flush_nogap(lame_flags, &buf[len], bufsize-len);
157     //printf("flush: %d (+%d)\n", len, len-oldlen);
158     oldlen = len;
159     
160     swf_SetBlock(tag, buf, len);
161
162    /* len += lame_encode_flush(lame_flags, &buf[len], bufsize-len);
163     printf("flush! %d (+%d)\n", len, len-oldlen);*/
164
165     free(buf);
166 }
167
168 void swf_SetSoundStreamEnd(TAG*tag)
169 {
170     lame_close (lame_flags);
171 }
172
173 void swf_SetSoundDefine(TAG*tag, S16*samples, int num)
174 {
175     char*buf;
176     int oldlen=0,len = 0;
177     int bufsize = 16384;
178     int blocksize = 1152*2;
179     int t;
180     int blocks;
181
182     U8 compression = 2; // 0 = raw, 1 = ADPCM, 2 = mp3, 3 = raw le, 6 = nellymoser
183     U8 rate = 1; // 0 = 5.5 Khz, 1 = 11 Khz, 2 = 22 Khz, 3 = 44 Khz
184     U8 size = 1; // 0 = 8 bit, 1 = 16 bit
185     U8 type = 0; // 0 = mono, 1 = stereo
186
187     blocks = num / (blocksize);
188
189     swf_SetU8(tag,(compression<<4)|(rate<<2)|(size<<1)|type);
190     swf_SetU32(tag,blocks*blocksize);
191
192     buf = malloc(bufsize);
193     if(!buf)
194         return;
195
196     initlame(buf, bufsize);
197
198     swf_SetU16(tag, 0); //delayseek
199     for(t=0;t<blocks;t++) {
200         int s;
201         U16*pos;
202         pos= &samples[t*blocksize];
203         len += lame_encode_buffer(lame_flags, pos, pos, blocksize, &buf[len], bufsize-len);
204         len += lame_encode_flush_nogap(lame_flags, &buf[len], bufsize-len);
205         swf_SetBlock(tag, buf, len);
206         len = 0;
207     }
208
209     free(buf);
210 }
211
212 #define SOUNDINFO_STOP 32
213 #define SOUNDINFO_NOMULTIPLE 16
214 #define SOUNDINFO_HASENVELOPE 8
215 #define SOUNDINFO_HASLOOPS 4
216 #define SOUNDINFO_HASOUTPOINT 2
217 #define SOUNDINFO_HASINPOINT 1
218
219 void swf_SetSoundInfo(TAG*tag, SOUNDINFO*info)
220 {
221     U8 flags = (info->stop?SOUNDINFO_STOP:0)
222               |(info->multiple?SOUNDINFO_NOMULTIPLE:0)
223               |(info->envelopes?SOUNDINFO_HASENVELOPE:0)
224               |(info->loops?SOUNDINFO_HASLOOPS:0)
225               |(info->outpoint?SOUNDINFO_HASOUTPOINT:0)
226               |(info->inpoint?SOUNDINFO_HASINPOINT:0);
227     swf_SetU8(tag, flags);
228     if(flags&SOUNDINFO_HASINPOINT)
229         swf_SetU32(tag, info->inpoint);
230     if(flags&SOUNDINFO_HASOUTPOINT)
231         swf_SetU32(tag, info->outpoint);
232     if(flags&SOUNDINFO_HASLOOPS)
233         swf_SetU16(tag, info->loops);
234     if(flags&SOUNDINFO_HASENVELOPE) {
235         int t;
236         swf_SetU8(tag, info->envelopes);
237         for(t=0;t<info->envelopes;t++) {
238             swf_SetU32(tag, info->pos[t]);
239             swf_SetU16(tag, info->left[t]);
240             swf_SetU16(tag, info->right[t]);
241         }
242     }
243 }
244
245 #endif
246
247 #endif // RFXSWF_DISABLESOUND