1 /********************************************************************
2 * *
3 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
7 * *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
10 * *
11 ********************************************************************
12
13 function: simple example decoder
14 last mod: $Id: decoder_example.c 16243 2009-07-10 02:49:31Z xiphmont $
15
16 ********************************************************************/
17
18 /* Takes a vorbis bitstream from stdin and writes raw stereo PCM to
19 stdout. Decodes simple and chained OggVorbis files from beginning
20 to end. Vorbisfile.a is somewhat more complex than the code below. */
21
22 /* Note that this is POSIX, not ANSI code */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <math.h>
27 #include <vorbis/codec.h>
28
29 #ifdef _WIN32 /* We need the following two to set stdin/stdout to binary */
30 #include <io.h>
31 #include <fcntl.h>
32 #endif
33
34 #if defined(__MACOS__) && defined(__MWERKS__)
35 #include <console.h> /* CodeWarrior's Mac "command-line" support */
36 #endif
37
38 ogg_int16_t convbuffer[4096]; /* take 8k out of the data segment, not the stack */
39 int convsize=4096;
40
41 extern void _VDBG_dump(void);
42
main()43 int main(){
44 ogg_sync_state oy; /* sync and verify incoming physical bitstream */
45 ogg_stream_state os; /* take physical pages, weld into a logical
46 stream of packets */
47 ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
48 ogg_packet op; /* one raw packet of data for decode */
49
50 vorbis_info vi; /* struct that stores all the static vorbis bitstream
51 settings */
52 vorbis_comment vc; /* struct that stores all the bitstream user comments */
53 vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
54 vorbis_block vb; /* local working space for packet->PCM decode */
55
56 char *buffer;
57 int bytes;
58
59 #ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
60 /* Beware the evil ifdef. We avoid these where we can, but this one we
61 cannot. Don't add any more, you'll probably go to hell if you do. */
62 _setmode( _fileno( stdin ), _O_BINARY );
63 _setmode( _fileno( stdout ), _O_BINARY );
64 #endif
65
66 #if defined(macintosh) && defined(__MWERKS__)
67 {
68 int argc;
69 char **argv;
70 argc=ccommand(&argv); /* get a "command line" from the Mac user */
71 /* this also lets the user set stdin and stdout */
72 }
73 #endif
74
75 /********** Decode setup ************/
76
77 ogg_sync_init(&oy); /* Now we can read pages */
78
79 while(1){ /* we repeat if the bitstream is chained */
80 int eos=0;
81 int i;
82
83 /* grab some data at the head of the stream. We want the first page
84 (which is guaranteed to be small and only contain the Vorbis
85 stream initial header) We need the first page to get the stream
86 serialno. */
87
88 /* submit a 4k block to libvorbis' Ogg layer */
89 buffer=ogg_sync_buffer(&oy,4096);
90 bytes=fread(buffer,1,4096,stdin);
91 ogg_sync_wrote(&oy,bytes);
92
93 /* Get the first page. */
94 if(ogg_sync_pageout(&oy,&og)!=1){
95 /* have we simply run out of data? If so, we're done. */
96 if(bytes<4096)break;
97
98 /* error case. Must not be Vorbis data */
99 fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n");
100 exit(1);
101 }
102
103 /* Get the serial number and set up the rest of decode. */
104 /* serialno first; use it to set up a logical stream */
105 ogg_stream_init(&os,ogg_page_serialno(&og));
106
107 /* extract the initial header from the first page and verify that the
108 Ogg bitstream is in fact Vorbis data */
109
110 /* I handle the initial header first instead of just having the code
111 read all three Vorbis headers at once because reading the initial
112 header is an easy way to identify a Vorbis bitstream and it's
113 useful to see that functionality seperated out. */
114
115 vorbis_info_init(&vi);
116 vorbis_comment_init(&vc);
117 if(ogg_stream_pagein(&os,&og)<0){
118 /* error; stream version mismatch perhaps */
119 fprintf(stderr,"Error reading first page of Ogg bitstream data.\n");
120 exit(1);
121 }
122
123 if(ogg_stream_packetout(&os,&op)!=1){
124 /* no page? must not be vorbis */
125 fprintf(stderr,"Error reading initial header packet.\n");
126 exit(1);
127 }
128
129 if(vorbis_synthesis_headerin(&vi,&vc,&op)<0){
130 /* error case; not a vorbis header */
131 fprintf(stderr,"This Ogg bitstream does not contain Vorbis "
132 "audio data.\n");
133 exit(1);
134 }
135
136 /* At this point, we're sure we're Vorbis. We've set up the logical
137 (Ogg) bitstream decoder. Get the comment and codebook headers and
138 set up the Vorbis decoder */
139
140 /* The next two packets in order are the comment and codebook headers.
141 They're likely large and may span multiple pages. Thus we read
142 and submit data until we get our two packets, watching that no
143 pages are missing. If a page is missing, error out; losing a
144 header page is the only place where missing data is fatal. */
145
146 i=0;
147 while(i<2){
148 while(i<2){
149 int result=ogg_sync_pageout(&oy,&og);
150 if(result==0)break; /* Need more data */
151 /* Don't complain about missing or corrupt data yet. We'll
152 catch it at the packet output phase */
153 if(result==1){
154 ogg_stream_pagein(&os,&og); /* we can ignore any errors here
155 as they'll also become apparent
156 at packetout */
157 while(i<2){
158 result=ogg_stream_packetout(&os,&op);
159 if(result==0)break;
160 if(result<0){
161 /* Uh oh; data at some point was corrupted or missing!
162 We can't tolerate that in a header. Die. */
163 fprintf(stderr,"Corrupt secondary header. Exiting.\n");
164 exit(1);
165 }
166 result=vorbis_synthesis_headerin(&vi,&vc,&op);
167 if(result<0){
168 fprintf(stderr,"Corrupt secondary header. Exiting.\n");
169 exit(1);
170 }
171 i++;
172 }
173 }
174 }
175 /* no harm in not checking before adding more */
176 buffer=ogg_sync_buffer(&oy,4096);
177 bytes=fread(buffer,1,4096,stdin);
178 if(bytes==0 && i<2){
179 fprintf(stderr,"End of file before finding all Vorbis headers!\n");
180 exit(1);
181 }
182 ogg_sync_wrote(&oy,bytes);
183 }
184
185 /* Throw the comments plus a few lines about the bitstream we're
186 decoding */
187 {
188 char **ptr=vc.user_comments;
189 while(*ptr){
190 fprintf(stderr,"%s\n",*ptr);
191 ++ptr;
192 }
193 fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi.channels,vi.rate);
194 fprintf(stderr,"Encoded by: %s\n\n",vc.vendor);
195 }
196
197 convsize=4096/vi.channels;
198
199 /* OK, got and parsed all three headers. Initialize the Vorbis
200 packet->PCM decoder. */
201 if(vorbis_synthesis_init(&vd,&vi)==0){ /* central decode state */
202 vorbis_block_init(&vd,&vb); /* local state for most of the decode
203 so multiple block decodes can
204 proceed in parallel. We could init
205 multiple vorbis_block structures
206 for vd here */
207
208 /* The rest is just a straight decode loop until end of stream */
209 while(!eos){
210 while(!eos){
211 int result=ogg_sync_pageout(&oy,&og);
212 if(result==0)break; /* need more data */
213 if(result<0){ /* missing or corrupt data at this page position */
214 fprintf(stderr,"Corrupt or missing data in bitstream; "
215 "continuing...\n");
216 }else{
217 ogg_stream_pagein(&os,&og); /* can safely ignore errors at
218 this point */
219 while(1){
220 result=ogg_stream_packetout(&os,&op);
221
222 if(result==0)break; /* need more data */
223 if(result<0){ /* missing or corrupt data at this page position */
224 /* no reason to complain; already complained above */
225 }else{
226 /* we have a packet. Decode it */
227 float **pcm;
228 int samples;
229
230 if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
231 vorbis_synthesis_blockin(&vd,&vb);
232 /*
233
234 **pcm is a multichannel float vector. In stereo, for
235 example, pcm[0] is left, and pcm[1] is right. samples is
236 the size of each channel. Convert the float values
237 (-1.<=range<=1.) to whatever PCM format and write it out */
238
239 while((samples=vorbis_synthesis_pcmout(&vd,&pcm))>0){
240 int j;
241 int clipflag=0;
242 int bout=(samples<convsize?samples:convsize);
243
244 /* convert floats to 16 bit signed ints (host order) and
245 interleave */
246 for(i=0;i<vi.channels;i++){
247 ogg_int16_t *ptr=convbuffer+i;
248 float *mono=pcm[i];
249 for(j=0;j<bout;j++){
250 #if 1
251 int val=floor(mono[j]*32767.f+.5f);
252 #else /* optional dither */
253 int val=mono[j]*32767.f+drand48()-0.5f;
254 #endif
255 /* might as well guard against clipping */
256 if(val>32767){
257 val=32767;
258 clipflag=1;
259 }
260 if(val<-32768){
261 val=-32768;
262 clipflag=1;
263 }
264 *ptr=val;
265 ptr+=vi.channels;
266 }
267 }
268
269 if(clipflag)
270 fprintf(stderr,"Clipping in frame %ld\n",(long)(vd.sequence));
271
272
273 fwrite(convbuffer,2*vi.channels,bout,stdout);
274
275 vorbis_synthesis_read(&vd,bout); /* tell libvorbis how
276 many samples we
277 actually consumed */
278 }
279 }
280 }
281 if(ogg_page_eos(&og))eos=1;
282 }
283 }
284 if(!eos){
285 buffer=ogg_sync_buffer(&oy,4096);
286 bytes=fread(buffer,1,4096,stdin);
287 ogg_sync_wrote(&oy,bytes);
288 if(bytes==0)eos=1;
289 }
290 }
291
292 /* ogg_page and ogg_packet structs always point to storage in
293 libvorbis. They're never freed or manipulated directly */
294
295 vorbis_block_clear(&vb);
296 vorbis_dsp_clear(&vd);
297 }else{
298 fprintf(stderr,"Error: Corrupt header during playback initialization.\n");
299 }
300
301 /* clean up this logical bitstream; before exit we see if we're
302 followed by another [chained] */
303
304 ogg_stream_clear(&os);
305 vorbis_comment_clear(&vc);
306 vorbis_info_clear(&vi); /* must be called last */
307 }
308
309 /* OK, clean up the framer */
310 ogg_sync_clear(&oy);
311
312 fprintf(stderr,"Done.\n");
313 return(0);
314 }
315