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 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
