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 http://www.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 }