]> git.tdb.fi Git - ext/vorbisfile.git/blob - examples/encoder_example.c
Add headers to the library component so dependencies work correctly
[ext/vorbisfile.git] / examples / encoder_example.c
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-2007             *
9  * by the Xiph.Org Foundation https://xiph.org/                     *
10  *                                                                  *
11  ********************************************************************
12
13  function: simple example encoder
14
15  ********************************************************************/
16
17 /* takes a stereo 16bit 44.1kHz WAV file from stdin and encodes it into
18    a Vorbis bitstream */
19
20 /* Note that this is POSIX, not ANSI, code */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <time.h>
26 #include <math.h>
27 #include <vorbis/vorbisenc.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 #define READ 1024
39 signed char readbuffer[READ*4+44]; /* out of the data segment, not the stack */
40
41 int main(){
42   ogg_stream_state os; /* take physical pages, weld into a logical
43                           stream of packets */
44   ogg_page         og; /* one Ogg bitstream page.  Vorbis packets are inside */
45   ogg_packet       op; /* one raw packet of data for decode */
46
47   vorbis_info      vi; /* struct that stores all the static vorbis bitstream
48                           settings */
49   vorbis_comment   vc; /* struct that stores all the user comments */
50
51   vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
52   vorbis_block     vb; /* local working space for packet->PCM decode */
53
54   int eos=0,ret;
55   int i, founddata;
56
57 #if defined(macintosh) && defined(__MWERKS__)
58   int argc = 0;
59   char **argv = NULL;
60   argc = ccommand(&argv); /* get a "command line" from the Mac user */
61                           /* this also lets the user set stdin and stdout */
62 #endif
63
64   /* we cheat on the WAV header; we just bypass 44 bytes (simplest WAV
65      header is 44 bytes) and assume that the data is 44.1khz, stereo, 16 bit
66      little endian pcm samples. This is just an example, after all. */
67
68 #ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
69   /* if we were reading/writing a file, it would also need to in
70      binary mode, eg, fopen("file.wav","wb"); */
71   /* Beware the evil ifdef. We avoid these where we can, but this one we
72      cannot. Don't add any more, you'll probably go to hell if you do. */
73   _setmode( _fileno( stdin ), _O_BINARY );
74   _setmode( _fileno( stdout ), _O_BINARY );
75 #endif
76
77
78   /* we cheat on the WAV header; we just bypass the header and never
79      verify that it matches 16bit/stereo/44.1kHz.  This is just an
80      example, after all. */
81
82   readbuffer[0] = '\0';
83   for (i=0, founddata=0; i<30 && ! feof(stdin) && ! ferror(stdin); i++)
84   {
85     fread(readbuffer,1,2,stdin);
86
87     if ( ! strncmp((char*)readbuffer, "da", 2) ){
88       founddata = 1;
89       fread(readbuffer,1,6,stdin);
90       break;
91     }
92   }
93
94   /********** Encode setup ************/
95
96   vorbis_info_init(&vi);
97
98   /* choose an encoding mode.  A few possibilities commented out, one
99      actually used: */
100
101   /*********************************************************************
102    Encoding using a VBR quality mode.  The usable range is -.1
103    (lowest quality, smallest file) to 1. (highest quality, largest file).
104    Example quality mode .4: 44kHz stereo coupled, roughly 128kbps VBR
105
106    ret = vorbis_encode_init_vbr(&vi,2,44100,.4);
107
108    ---------------------------------------------------------------------
109
110    Encoding using an average bitrate mode (ABR).
111    example: 44kHz stereo coupled, average 128kbps VBR
112
113    ret = vorbis_encode_init(&vi,2,44100,-1,128000,-1);
114
115    ---------------------------------------------------------------------
116
117    Encode using a quality mode, but select that quality mode by asking for
118    an approximate bitrate.  This is not ABR, it is true VBR, but selected
119    using the bitrate interface, and then turning bitrate management off:
120
121    ret = ( vorbis_encode_setup_managed(&vi,2,44100,-1,128000,-1) ||
122            vorbis_encode_ctl(&vi,OV_ECTL_RATEMANAGE2_SET,NULL) ||
123            vorbis_encode_setup_init(&vi));
124
125    *********************************************************************/
126
127   ret=vorbis_encode_init_vbr(&vi,2,44100,0.1);
128
129   /* do not continue if setup failed; this can happen if we ask for a
130      mode that libVorbis does not support (eg, too low a bitrate, etc,
131      will return 'OV_EIMPL') */
132
133   if(ret)exit(1);
134
135   /* add a comment */
136   vorbis_comment_init(&vc);
137   vorbis_comment_add_tag(&vc,"ENCODER","encoder_example.c");
138
139   /* set up the analysis state and auxiliary encoding storage */
140   vorbis_analysis_init(&vd,&vi);
141   vorbis_block_init(&vd,&vb);
142
143   /* set up our packet->stream encoder */
144   /* pick a random serial number; that way we can more likely build
145      chained streams just by concatenation */
146   srand(time(NULL));
147   ogg_stream_init(&os,rand());
148
149   /* Vorbis streams begin with three headers; the initial header (with
150      most of the codec setup parameters) which is mandated by the Ogg
151      bitstream spec.  The second header holds any comment fields.  The
152      third header holds the bitstream codebook.  We merely need to
153      make the headers, then pass them to libvorbis one at a time;
154      libvorbis handles the additional Ogg bitstream constraints */
155
156   {
157     ogg_packet header;
158     ogg_packet header_comm;
159     ogg_packet header_code;
160
161     vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
162     ogg_stream_packetin(&os,&header); /* automatically placed in its own
163                                          page */
164     ogg_stream_packetin(&os,&header_comm);
165     ogg_stream_packetin(&os,&header_code);
166
167     /* This ensures the actual
168      * audio data will start on a new page, as per spec
169      */
170     while(!eos){
171       int result=ogg_stream_flush(&os,&og);
172       if(result==0)break;
173       fwrite(og.header,1,og.header_len,stdout);
174       fwrite(og.body,1,og.body_len,stdout);
175     }
176
177   }
178
179   while(!eos){
180     long i;
181     long bytes=fread(readbuffer,1,READ*4,stdin); /* stereo hardwired here */
182
183     if(bytes==0){
184       /* end of file.  this can be done implicitly in the mainline,
185          but it's easier to see here in non-clever fashion.
186          Tell the library we're at end of stream so that it can handle
187          the last frame and mark end of stream in the output properly */
188       vorbis_analysis_wrote(&vd,0);
189
190     }else{
191       /* data to encode */
192
193       /* expose the buffer to submit data */
194       float **buffer=vorbis_analysis_buffer(&vd,READ);
195
196       /* uninterleave samples */
197       for(i=0;i<bytes/4;i++){
198         buffer[0][i]=((readbuffer[i*4+1]<<8)|
199                       (0x00ff&(int)readbuffer[i*4]))/32768.f;
200         buffer[1][i]=((readbuffer[i*4+3]<<8)|
201                       (0x00ff&(int)readbuffer[i*4+2]))/32768.f;
202       }
203
204       /* tell the library how much we actually submitted */
205       vorbis_analysis_wrote(&vd,i);
206     }
207
208     /* vorbis does some data preanalysis, then divvies up blocks for
209        more involved (potentially parallel) processing.  Get a single
210        block for encoding now */
211     while(vorbis_analysis_blockout(&vd,&vb)==1){
212
213       /* analysis, assume we want to use bitrate management */
214       vorbis_analysis(&vb,NULL);
215       vorbis_bitrate_addblock(&vb);
216
217       while(vorbis_bitrate_flushpacket(&vd,&op)){
218
219         /* weld the packet into the bitstream */
220         ogg_stream_packetin(&os,&op);
221
222         /* write out pages (if any) */
223         while(!eos){
224           int result=ogg_stream_pageout(&os,&og);
225           if(result==0)break;
226           fwrite(og.header,1,og.header_len,stdout);
227           fwrite(og.body,1,og.body_len,stdout);
228
229           /* this could be set above, but for illustrative purposes, I do
230              it here (to show that vorbis does know where the stream ends) */
231
232           if(ogg_page_eos(&og))eos=1;
233         }
234       }
235     }
236   }
237
238   /* clean up and exit.  vorbis_info_clear() must be called last */
239
240   ogg_stream_clear(&os);
241   vorbis_block_clear(&vb);
242   vorbis_dsp_clear(&vd);
243   vorbis_comment_clear(&vc);
244   vorbis_info_clear(&vi);
245
246   /* ogg_page and ogg_packet structs always point to storage in
247      libvorbis.  They're never freed or manipulated directly */
248
249   fprintf(stderr,"Done.\n");
250   return(0);
251 }