Got the Ogg encoder and decoder to (barely) work.
authorJean-Marc Valin <Jean-Marc.Valin@csiro.au>
Fri, 1 Feb 2008 05:27:38 +0000 (16:27 +1100)
committerJean-Marc Valin <Jean-Marc.Valin@csiro.au>
Fri, 1 Feb 2008 05:27:38 +0000 (16:27 +1100)
Makefile.am
configure.ac
tests/Makefile.am
tools/celtdec.c [new file with mode: 0644]
tools/getopt.c [new file with mode: 0644]
tools/getopt1.c [new file with mode: 0644]
tools/getopt_win.h [new file with mode: 0644]
tools/wave_out.c [new file with mode: 0644]
tools/wave_out.h [new file with mode: 0644]

index a55fb9b..3356008 100644 (file)
@@ -5,7 +5,9 @@
 AUTOMAKE_OPTIONS = 1.6
 
 #Fools KDevelop into including all files
-SUBDIRS = libcelt tests
+SUBDIRS = libcelt tests @tools@
+
+DIST_SUBDIRS = libcelt tests tools
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = celt.pc 
index db2e233..41c0782 100644 (file)
@@ -47,6 +47,7 @@ has_var_arrays=no
 )
 AC_MSG_RESULT($has_var_arrays)
 
+AC_CHECK_HEADERS([alloca.h getopt.h])
 AC_MSG_CHECKING(for alloca)
 AC_TRY_COMPILE( [#include <alloca.h>], [
 int foo=10;
@@ -65,8 +66,8 @@ AC_MSG_RESULT($has_alloca)
 
 AC_CHECK_HEADERS(sys/soundcard.h sys/audioio.h)
 
-XIPH_PATH_OGG([src="src"], [src=""])
-AC_SUBST(src)
+XIPH_PATH_OGG([tools="tools"], [tools=""])
+AC_SUBST(tools)
 
 AC_CHECK_LIB(m, sin)
 
@@ -121,9 +122,9 @@ fi
 AC_SUBST(SIZE16)
 AC_SUBST(SIZE32)
 
-AC_OUTPUT([Makefile libcelt/Makefile tests/Makefile celt.pc])
+AC_OUTPUT([Makefile libcelt/Makefile tests/Makefile celt.pc tools/Makefile])
 
-if test "x$src" = "x"; then 
+if test "x$tools" = "x"; then 
 echo "**IMPORTANT**"
 echo "You don't seem to have the development package for libogg (libogg-devel) installed. Only the library will be built (no encoder/decoder executable)"
 echo "You can download libogg from http://www.vorbis.com/download.psp"
index c160e81..03c7ade 100644 (file)
@@ -5,8 +5,8 @@ TESTS = type-test ectest cwrs32-test cwrs64-test
 
 bin_PROGRAMS = type-test ectest cwrs32-test cwrs64-test
 
-ectest_SOURCES = type-test.c
-ectest_LDADD = $(top_builddir)/libcelt/libcelt.la
+type_test_SOURCES = type-test.c
+type_test_LDADD = $(top_builddir)/libcelt/libcelt.la
 
 ectest_SOURCES = ectest.c
 ectest_LDADD = $(top_builddir)/libcelt/libcelt.la
diff --git a/tools/celtdec.c b/tools/celtdec.c
new file mode 100644 (file)
index 0000000..7d7952c
--- /dev/null
@@ -0,0 +1,722 @@
+/* Copyright (C) 2008 Jean-Marc Valin, CSIRO
+   File: celtdec.c
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+   
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+   
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+   
+   - Neither the name of the Xiph.org Foundation nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+   
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#if !defined WIN32 && !defined _WIN32
+#include <unistd.h>
+#endif
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#endif
+#ifndef HAVE_GETOPT_LONG
+#include "getopt_win.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+
+#include <celt.h>
+#include <ogg/ogg.h>
+
+#if defined WIN32 || defined _WIN32
+#include "wave_out.h"
+/* We need the following two to set stdout to binary */
+#include <io.h>
+#include <fcntl.h>
+#endif
+#include <math.h>
+
+#ifdef __MINGW32__
+#include "wave_out.c"
+#endif
+
+#ifdef HAVE_SYS_SOUNDCARD_H
+#include <sys/soundcard.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#elif defined HAVE_SYS_AUDIOIO_H
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#ifndef AUDIO_ENCODING_SLINEAR
+#define AUDIO_ENCODING_SLINEAR AUDIO_ENCODING_LINEAR /* Solaris */
+#endif
+
+#endif
+
+#include <string.h>
+#include "wav_io.h"
+#include <celt_header.h>
+
+#define MAX_FRAME_SIZE 2000
+
+#define readint(buf, base) (((buf[base+3]<<24)&0xff000000)| \
+                           ((buf[base+2]<<16)&0xff0000)| \
+                           ((buf[base+1]<<8)&0xff00)| \
+                           (buf[base]&0xff))
+
+static void print_comments(char *comments, int length)
+{
+   char *c=comments;
+   int len, i, nb_fields;
+   char *end;
+   
+   if (length<8)
+   {
+      fprintf (stderr, "Invalid/corrupted comments\n");
+      return;
+   }
+   end = c+length;
+   len=readint(c, 0);
+   c+=4;
+   if (c+len>end)
+   {
+      fprintf (stderr, "Invalid/corrupted comments\n");
+      return;
+   }
+   fwrite(c, 1, len, stderr);
+   c+=len;
+   fprintf (stderr, "\n");
+   if (c+4>end)
+   {
+      fprintf (stderr, "Invalid/corrupted comments\n");
+      return;
+   }
+   nb_fields=readint(c, 0);
+   c+=4;
+   for (i=0;i<nb_fields;i++)
+   {
+      if (c+4>end)
+      {
+         fprintf (stderr, "Invalid/corrupted comments\n");
+         return;
+      }
+      len=readint(c, 0);
+      c+=4;
+      if (c+len>end)
+      {
+         fprintf (stderr, "Invalid/corrupted comments\n");
+         return;
+      }
+      fwrite(c, 1, len, stderr);
+      c+=len;
+      fprintf (stderr, "\n");
+   }
+}
+
+FILE *out_file_open(char *outFile, int rate, int *channels)
+{
+   FILE *fout=NULL;
+   /*Open output file*/
+   if (strlen(outFile)==0)
+   {
+#if defined HAVE_SYS_SOUNDCARD_H
+      int audio_fd, format, stereo;
+      audio_fd=open("/dev/dsp", O_WRONLY);
+      if (audio_fd<0)
+      {
+         perror("Cannot open /dev/dsp");
+         exit(1);         
+      }
+
+      format=AFMT_S16_NE;
+      if (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &format)==-1)
+      {
+         perror("SNDCTL_DSP_SETFMT");
+         close(audio_fd);
+         exit(1);
+      }
+
+      stereo=0;
+      if (*channels==2)
+         stereo=1;
+      if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo)==-1)
+      {
+         perror("SNDCTL_DSP_STEREO");
+         close(audio_fd);
+         exit(1);
+      }
+      if (stereo!=0)
+      {
+         if (*channels==1)
+            fprintf (stderr, "Cannot set mono mode, will decode in stereo\n");
+         *channels=2;
+      }
+
+      if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &rate)==-1)
+      {
+         perror("SNDCTL_DSP_SPEED");
+         close(audio_fd);
+         exit(1);
+      }
+      fout = fdopen(audio_fd, "w");
+#elif defined HAVE_SYS_AUDIOIO_H
+      audio_info_t info;
+      int audio_fd;
+      
+      audio_fd = open("/dev/audio", O_WRONLY);
+      if (audio_fd<0)
+      {
+         perror("Cannot open /dev/audio");
+         exit(1);
+      }
+
+      AUDIO_INITINFO(&info);
+#ifdef AUMODE_PLAY    /* NetBSD/OpenBSD */
+      info.mode = AUMODE_PLAY;
+#endif
+      info.play.encoding = AUDIO_ENCODING_SLINEAR;
+      info.play.precision = 16;
+      info.play.sample_rate = rate;
+      info.play.channels = *channels;
+      
+      if (ioctl(audio_fd, AUDIO_SETINFO, &info) < 0)
+      {
+         perror ("AUDIO_SETINFO");
+         exit(1);
+      }
+      fout = fdopen(audio_fd, "w");
+#elif defined WIN32 || defined _WIN32
+      {
+         unsigned int celt_channels = *channels;
+         if (Set_WIN_Params (INVALID_FILEDESC, rate, SAMPLE_SIZE, celt_channels))
+         {
+            fprintf (stderr, "Can't access %s\n", "WAVE OUT");
+            exit(1);
+         }
+      }
+#else
+      fprintf (stderr, "No soundcard support\n");
+      exit(1);
+#endif
+   } else {
+      if (strcmp(outFile,"-")==0)
+      {
+#if defined WIN32 || defined _WIN32
+         _setmode(_fileno(stdout), _O_BINARY);
+#endif
+         fout=stdout;
+      }
+      else 
+      {
+         fout = fopen(outFile, "wb");
+         if (!fout)
+         {
+            perror(outFile);
+            exit(1);
+         }
+         if (strcmp(outFile+strlen(outFile)-4,".wav")==0 || strcmp(outFile+strlen(outFile)-4,".WAV")==0)
+            write_wav_header(fout, rate, *channels, 0, 0);
+      }
+   }
+   return fout;
+}
+
+void usage()
+{
+   printf ("Usage: celtdec [options] input_file.spx [output_file]\n");
+   printf ("\n");
+   printf ("Decodes a CELT file and produce a WAV file or raw file\n");
+   printf ("\n");
+   printf ("input_file can be:\n");
+   printf ("  filename.oga         regular CELT file\n");
+   printf ("  -                    stdin\n");
+   printf ("\n");  
+   printf ("output_file can be:\n");
+   printf ("  filename.wav         Wav file\n");
+   printf ("  filename.*           Raw PCM file (any extension other that .wav)\n");
+   printf ("  -                    stdout\n");
+   printf ("  (nothing)            Will be played to soundcard\n");
+   printf ("\n");  
+   printf ("Options:\n");
+   printf (" --enh                 Enable perceptual enhancement (default)\n");
+   printf (" --no-enh              Disable perceptual enhancement\n");
+   printf (" --force-nb            Force decoding in narrowband\n");
+   printf (" --force-wb            Force decoding in wideband\n");
+   printf (" --force-uwb           Force decoding in ultra-wideband\n");
+   printf (" --mono                Force decoding in mono\n");
+   printf (" --stereo              Force decoding in stereo\n");
+   printf (" --rate n              Force decoding at sampling rate n Hz\n");
+   printf (" --packet-loss n       Simulate n %% random packet loss\n");
+   printf (" -V                    Verbose mode (show bit-rate)\n"); 
+   printf (" -h, --help            This help\n");
+   printf (" -v, --version         Version information\n");
+   printf (" --pf                  Deprecated, use --enh instead\n");
+   printf (" --no-pf               Deprecated, use --no-enh instead\n");
+   printf ("\n");
+}
+
+void version()
+{
+   printf ("celtenc (CELT encoder)\n");
+   printf ("Copyright (C) 2008 Jean-Marc Valin\n");
+}
+
+void version_short()
+{
+   printf ("celtenc (CELT encoder)\n");
+   printf ("Copyright (C) 2008 Jean-Marc Valin\n");
+}
+
+static CELTDecoder *process_header(ogg_packet *op, celt_int32_t enh_enabled, celt_int32_t *frame_size, int *granule_frame_size, celt_int32_t *rate, int *nframes, int forceMode, int *channels, int *extra_headers, int quiet)
+{
+   CELTDecoder *st;
+   const CELTMode *mode;
+   CELTHeader header;
+   int modeID;
+      
+   celt_header_from_packet((char*)op->packet, op->bytes, &header);
+      
+   if (header.mode==0)
+      mode = celt_mono;
+   else if (header.mode==1)
+      mode = celt_stereo;
+   else
+   {
+      fprintf (stderr, "Invalid mode: %d\n", header.mode);
+      return NULL;
+   }
+
+   st = celt_decoder_new(mode);
+   if (!st)
+   {
+      fprintf (stderr, "Decoder initialization failed.\n");
+      return NULL;
+   }
+   
+   celt_mode_info(mode, CELT_GET_FRAME_SIZE, frame_size);
+   *granule_frame_size = *frame_size;
+
+   if (!*rate)
+      *rate = header.sample_rate;
+   /* Adjust rate if --force-* options are used */
+
+   *nframes = 1;
+
+   if (*channels==-1)
+      *channels = header.nb_channels;
+   
+   if (!quiet)
+   {
+      fprintf (stderr, "Decoding %d Hz audio in", *rate);
+
+      if (*channels==1)
+         fprintf (stderr, " (mono");
+      else
+         fprintf (stderr, " (stereo");
+      
+   }
+
+   *extra_headers = header.extra_headers;
+
+   return st;
+}
+
+int main(int argc, char **argv)
+{
+   int c;
+   int option_index = 0;
+   char *inFile, *outFile;
+   FILE *fin, *fout=NULL;
+   short out[MAX_FRAME_SIZE];
+   short output[MAX_FRAME_SIZE];
+   int frame_size=0, granule_frame_size=0;
+   void *st=NULL;
+   unsigned char bits[1000];
+   int packet_count=0;
+   int stream_init = 0;
+   int quiet = 0;
+   ogg_int64_t page_granule=0, last_granule=0;
+   int skip_samples=0, page_nb_packets;
+   struct option long_options[] =
+   {
+      {"help", no_argument, NULL, 0},
+      {"quiet", no_argument, NULL, 0},
+      {"version", no_argument, NULL, 0},
+      {"version-short", no_argument, NULL, 0},
+      {"enh", no_argument, NULL, 0},
+      {"no-enh", no_argument, NULL, 0},
+      {"pf", no_argument, NULL, 0},
+      {"no-pf", no_argument, NULL, 0},
+      {"force-nb", no_argument, NULL, 0},
+      {"force-wb", no_argument, NULL, 0},
+      {"force-uwb", no_argument, NULL, 0},
+      {"rate", required_argument, NULL, 0},
+      {"mono", no_argument, NULL, 0},
+      {"stereo", no_argument, NULL, 0},
+      {"packet-loss", required_argument, NULL, 0},
+      {0, 0, 0, 0}
+   };
+   ogg_sync_state oy;
+   ogg_page       og;
+   ogg_packet     op;
+   ogg_stream_state os;
+   int enh_enabled;
+   int nframes=2;
+   int print_bitrate=0;
+   int close_in=0;
+   int eos=0;
+   int forceMode=-1;
+   int audio_size=0;
+   float loss_percent=-1;
+   int channels=-1;
+   int rate=0;
+   int extra_headers=0;
+   int wav_format=0;
+   int lookahead;
+   int celt_serialno = -1;
+
+   enh_enabled = 1;
+
+   /*Process options*/
+   while(1)
+   {
+      c = getopt_long (argc, argv, "hvV",
+                       long_options, &option_index);
+      if (c==-1)
+         break;
+      
+      switch(c)
+      {
+      case 0:
+         if (strcmp(long_options[option_index].name,"help")==0)
+         {
+            usage();
+            exit(0);
+         } else if (strcmp(long_options[option_index].name,"quiet")==0)
+         {
+            quiet = 1;
+         } else if (strcmp(long_options[option_index].name,"version")==0)
+         {
+            version();
+            exit(0);
+         } else if (strcmp(long_options[option_index].name,"version-short")==0)
+         {
+            version_short();
+            exit(0);
+         } else if (strcmp(long_options[option_index].name,"enh")==0)
+         {
+            enh_enabled=1;
+         } else if (strcmp(long_options[option_index].name,"no-enh")==0)
+         {
+            enh_enabled=0;
+         } else if (strcmp(long_options[option_index].name,"pf")==0)
+         {
+            fprintf (stderr, "--pf is deprecated, use --enh instead\n");
+            enh_enabled=1;
+         } else if (strcmp(long_options[option_index].name,"no-pf")==0)
+         {
+            fprintf (stderr, "--no-pf is deprecated, use --no-enh instead\n");
+            enh_enabled=0;
+         } else if (strcmp(long_options[option_index].name,"force-nb")==0)
+         {
+            forceMode=0;
+         } else if (strcmp(long_options[option_index].name,"force-wb")==0)
+         {
+            forceMode=1;
+         } else if (strcmp(long_options[option_index].name,"force-uwb")==0)
+         {
+            forceMode=2;
+         } else if (strcmp(long_options[option_index].name,"mono")==0)
+         {
+            channels=1;
+         } else if (strcmp(long_options[option_index].name,"stereo")==0)
+         {
+            channels=2;
+         } else if (strcmp(long_options[option_index].name,"rate")==0)
+         {
+            rate=atoi (optarg);
+         } else if (strcmp(long_options[option_index].name,"packet-loss")==0)
+         {
+            loss_percent = atof(optarg);
+         }
+         break;
+      case 'h':
+         usage();
+         exit(0);
+         break;
+      case 'v':
+         version();
+         exit(0);
+         break;
+      case 'V':
+         print_bitrate=1;
+         break;
+      case '?':
+         usage();
+         exit(1);
+         break;
+      }
+   }
+   if (argc-optind!=2 && argc-optind!=1)
+   {
+      usage();
+      exit(1);
+   }
+   inFile=argv[optind];
+
+   if (argc-optind==2)
+      outFile=argv[optind+1];
+   else
+      outFile = "";
+   wav_format = strlen(outFile)>=4 && (
+                                       strcmp(outFile+strlen(outFile)-4,".wav")==0
+                                       || strcmp(outFile+strlen(outFile)-4,".WAV")==0);
+   /*Open input file*/
+   if (strcmp(inFile, "-")==0)
+   {
+#if defined WIN32 || defined _WIN32
+      _setmode(_fileno(stdin), _O_BINARY);
+#endif
+      fin=stdin;
+   }
+   else 
+   {
+      fin = fopen(inFile, "rb");
+      if (!fin)
+      {
+         perror(inFile);
+         exit(1);
+      }
+      close_in=1;
+   }
+
+
+   /*Init Ogg data struct*/
+   ogg_sync_init(&oy);
+   
+   /*Main decoding loop*/
+   
+   while (1)
+   {
+      char *data;
+      int i, j, nb_read;
+      /*Get the ogg buffer for writing*/
+      data = ogg_sync_buffer(&oy, 200);
+      /*Read bitstream from input file*/
+      nb_read = fread(data, sizeof(char), 200, fin);      
+      ogg_sync_wrote(&oy, nb_read);
+
+      /*Loop for all complete pages we got (most likely only one)*/
+      while (ogg_sync_pageout(&oy, &og)==1)
+      {
+         int packet_no;
+         if (stream_init == 0) {
+            ogg_stream_init(&os, ogg_page_serialno(&og));
+            stream_init = 1;
+         }
+        if (ogg_page_serialno(&og) != os.serialno) {
+           /* so all streams are read. */
+           ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
+        }
+         /*Add page to the bitstream*/
+         ogg_stream_pagein(&os, &og);
+         page_granule = ogg_page_granulepos(&og);
+         page_nb_packets = ogg_page_packets(&og);
+         if (page_granule>0 && frame_size)
+         {
+            /* FIXME: shift the granule values if --force-* is specified */
+            skip_samples = frame_size*(page_nb_packets*granule_frame_size*nframes - (page_granule-last_granule))/granule_frame_size;
+            if (ogg_page_eos(&og))
+               skip_samples = -skip_samples;
+            /*else if (!ogg_page_bos(&og))
+               skip_samples = 0;*/
+         } else
+         {
+            skip_samples = 0;
+         }
+         /*printf ("page granulepos: %d %d %d\n", skip_samples, page_nb_packets, (int)page_granule);*/
+         last_granule = page_granule;
+         /*Extract all available packets*/
+         packet_no=0;
+         while (!eos && ogg_stream_packetout(&os, &op) == 1)
+         {
+           if (!memcmp(op.packet, "CELT    ", 8)) {
+          fprintf (stderr, "Found it!\n");
+              celt_serialno = os.serialno;
+           }
+           if (celt_serialno == -1 || os.serialno != celt_serialno)
+              break;
+            /*If first packet, process as CELT header*/
+            if (packet_count==0)
+            {
+               st = process_header(&op, enh_enabled, &frame_size, &granule_frame_size, &rate, &nframes, forceMode, &channels, &extra_headers, quiet);
+               if (!st)
+                  exit(1);
+               //FIXME: Do that properly
+               //celt_decoder_ctl(st, SPEEX_GET_LOOKAHEAD, &lookahead);
+               lookahead = 0;
+               if (!nframes)
+                  nframes=1;
+               fout = out_file_open(outFile, rate, &channels);
+
+            } else if (packet_count==1)
+            {
+               if (!quiet)
+                  print_comments((char*)op.packet, op.bytes);
+            } else if (packet_count<=1+extra_headers)
+            {
+               /* Ignore extra headers */
+            } else {
+               int lost=0;
+               packet_no++;
+               if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
+                  lost=1;
+
+               /*End of stream condition*/
+               if (op.e_o_s && os.serialno == celt_serialno) /* don't care for anything except celt eos */
+                  eos=1;
+              
+               {
+                  int ret;
+                  /*Decode frame*/
+                  if (!lost)
+                     ret = celt_decode(st, (unsigned char*)op.packet, op.bytes, output);
+                  else
+                     ret = celt_decode(st, NULL, 0, output);
+
+                  fprintf (stderr, "dec %d %d\n", frame_size, channels);
+                  /*for (i=0;i<frame_size*channels;i++)
+                    printf ("%d\n", (int)output[i]);*/
+
+                  if (ret!=0)
+                  {
+                     fprintf (stderr, "Decoding error: corrupted stream?\n");
+                     break;
+                  }
+
+                  if (print_bitrate) {
+                     celt_int32_t tmp=40;
+                     char ch=13;
+                     fputc (ch, stderr);
+                     fprintf (stderr, "Bitrate is use: %d bytes/packet     ", tmp);
+                  }
+                  /*Convert to short and save to output file*/
+                  if (strlen(outFile)!=0)
+                  {
+                     for (i=0;i<frame_size*channels;i++)
+                        out[i]=le_short(output[i]);
+                  } else {
+                     for (i=0;i<frame_size*channels;i++)
+                        out[i]=output[i];
+                  }
+                  {
+                     int frame_offset = 0;
+                     int new_frame_size = frame_size;
+                     /*printf ("packet %d %d\n", packet_no, skip_samples);*/
+                     /*fprintf (stderr, "packet %d %d %d\n", packet_no, skip_samples, lookahead);*/
+                     if (packet_no == 1 && j==0 && skip_samples > 0)
+                     {
+                        /*printf ("chopping first packet\n");*/
+                        new_frame_size -= skip_samples+lookahead;
+                        frame_offset = skip_samples+lookahead;
+                     }
+                     if (packet_no == page_nb_packets && skip_samples < 0)
+                     {
+                        int packet_length = nframes*frame_size+skip_samples+lookahead;
+                        new_frame_size = packet_length - j*frame_size;
+                        if (new_frame_size<0)
+                           new_frame_size = 0;
+                        if (new_frame_size>frame_size)
+                           new_frame_size = frame_size;
+                        /*printf ("chopping end: %d %d %d\n", new_frame_size, packet_length, packet_no);*/
+                     }
+                     if (new_frame_size>0)
+                     {  
+#if defined WIN32 || defined _WIN32
+                        if (strlen(outFile)==0)
+                           WIN_Play_Samples (out+frame_offset*channels, sizeof(short) * new_frame_size*channels);
+                        else
+#endif
+                           fwrite(out+frame_offset*channels, sizeof(short), new_frame_size*channels, fout);
+                  
+                        audio_size+=sizeof(short)*new_frame_size*channels;
+                     }
+                  }
+               }
+            }
+            packet_count++;
+         }
+      }
+      if (feof(fin))
+         break;
+
+   }
+
+   if (fout && wav_format)
+   {
+      if (fseek(fout,4,SEEK_SET)==0)
+      {
+         int tmp;
+         tmp = le_int(audio_size+36);
+         fwrite(&tmp,4,1,fout);
+         if (fseek(fout,32,SEEK_CUR)==0)
+         {
+            tmp = le_int(audio_size);
+            fwrite(&tmp,4,1,fout);
+         } else
+         {
+            fprintf (stderr, "First seek worked, second didn't\n");
+         }
+      } else {
+         fprintf (stderr, "Cannot seek on wave file, size will be incorrect\n");
+      }
+   }
+
+   if (st)
+      celt_decoder_destroy(st);
+   else 
+   {
+      fprintf (stderr, "This doesn't look like a CELT file\n");
+   }
+   if (stream_init)
+      ogg_stream_clear(&os);
+   ogg_sync_clear(&oy);
+
+#if defined WIN32 || defined _WIN32
+   if (strlen(outFile)==0)
+      WIN_Audio_close ();
+#endif
+
+   if (close_in)
+      fclose(fin);
+   if (fout != NULL)
+      fclose(fout);   
+
+   return 0;
+}
diff --git a/tools/getopt.c b/tools/getopt.c
new file mode 100644 (file)
index 0000000..33d299b
--- /dev/null
@@ -0,0 +1,1047 @@
+/* Getopt for GNU.\r
+   NOTE: getopt is now part of the C library, so if you don't know what\r
+   "Keep this file name-space clean" means, talk to drepper@gnu.org\r
+   before changing it!\r
+\r
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99\r
+       Free Software Foundation, Inc.\r
+\r
+   The GNU C Library is free software; you can redistribute it and/or\r
+   modify it under the terms of the GNU Library General Public License as\r
+   published by the Free Software Foundation; either version 2 of the\r
+   License, or (at your option) any later version.\r
+\r
+   The GNU C Library is distributed in the hope that it will be useful,\r
+   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+   Library General Public License for more details.\r
+\r
+   You should have received a copy of the GNU Library General Public\r
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,\r
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
+   Boston, MA 02111-1307, USA.  */\r
+\r
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.\r
+   Ditto for AIX 3.2 and <stdlib.h>.  */\r
+#ifndef _NO_PROTO\r
+# define _NO_PROTO\r
+#endif\r
+\r
+#ifdef HAVE_CONFIG_H\r
+# include "config.h"\r
+#endif\r
+\r
+#if !defined __STDC__ || !__STDC__\r
+/* This is a separate conditional since some stdc systems\r
+   reject `defined (const)'.  */\r
+# ifndef const\r
+#  define const\r
+# endif\r
+#endif\r
+\r
+#include <stdio.h>\r
+\r
+/* Comment out all this code if we are using the GNU C Library, and are not\r
+   actually compiling the library itself.  This code is part of the GNU C\r
+   Library, but also included in many other GNU distributions.  Compiling\r
+   and linking in this code is a waste when using the GNU C library\r
+   (especially if it is a shared library).  Rather than having every GNU\r
+   program understand `configure --with-gnu-libc' and omit the object files,\r
+   it is simpler to just do this in the source for each such file.  */\r
+\r
+#define GETOPT_INTERFACE_VERSION 2\r
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2\r
+# include <gnu-versions.h>\r
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION\r
+#  define ELIDE_CODE\r
+# endif\r
+#endif\r
+\r
+#ifndef ELIDE_CODE\r
+\r
+\r
+/* This needs to come after some library #include\r
+   to get __GNU_LIBRARY__ defined.  */\r
+#ifdef __GNU_LIBRARY__\r
+/* Don't include stdlib.h for non-GNU C libraries because some of them\r
+   contain conflicting prototypes for getopt.  */\r
+# include <stdlib.h>\r
+# include <unistd.h>\r
+#endif /* GNU C library.  */\r
+\r
+#ifdef VMS\r
+# include <unixlib.h>\r
+# if HAVE_STRING_H - 0\r
+#  include <string.h>\r
+# endif\r
+#endif\r
+\r
+#ifndef _\r
+/* This is for other GNU distributions with internationalized messages.\r
+   When compiling libc, the _ macro is predefined.  */\r
+# ifdef HAVE_LIBINTL_H\r
+#  include <libintl.h>\r
+#  define _(msgid)     gettext (msgid)\r
+# else\r
+#  define _(msgid)     (msgid)\r
+# endif\r
+#endif\r
+\r
+/* This version of `getopt' appears to the caller like standard Unix `getopt'\r
+   but it behaves differently for the user, since it allows the user\r
+   to intersperse the options with the other arguments.\r
+\r
+   As `getopt' works, it permutes the elements of ARGV so that,\r
+   when it is done, all the options precede everything else.  Thus\r
+   all application programs are extended to handle flexible argument order.\r
+\r
+   Setting the environment variable POSIXLY_CORRECT disables permutation.\r
+   Then the behavior is completely standard.\r
+\r
+   GNU application programs can use a third alternative mode in which\r
+   they can distinguish the relative order of options and other arguments.  */\r
+\r
+#include "getopt_win.h"\r
+\r
+/* For communication from `getopt' to the caller.\r
+   When `getopt' finds an option that takes an argument,\r
+   the argument value is returned here.\r
+   Also, when `ordering' is RETURN_IN_ORDER,\r
+   each non-option ARGV-element is returned here.  */\r
+\r
+char *optarg;\r
+\r
+/* Index in ARGV of the next element to be scanned.\r
+   This is used for communication to and from the caller\r
+   and for communication between successive calls to `getopt'.\r
+\r
+   On entry to `getopt', zero means this is the first call; initialize.\r
+\r
+   When `getopt' returns -1, this is the index of the first of the\r
+   non-option elements that the caller should itself scan.\r
+\r
+   Otherwise, `optind' communicates from one call to the next\r
+   how much of ARGV has been scanned so far.  */\r
+\r
+/* 1003.2 says this must be 1 before any call.  */\r
+int optind = 1;\r
+\r
+/* Formerly, initialization of getopt depended on optind==0, which\r
+   causes problems with re-calling getopt as programs generally don't\r
+   know that. */\r
+\r
+int __getopt_initialized;\r
+\r
+/* The next char to be scanned in the option-element\r
+   in which the last option character we returned was found.\r
+   This allows us to pick up the scan where we left off.\r
+\r
+   If this is zero, or a null string, it means resume the scan\r
+   by advancing to the next ARGV-element.  */\r
+\r
+static char *nextchar;\r
+\r
+/* Callers store zero here to inhibit the error message\r
+   for unrecognized options.  */\r
+\r
+int opterr = 1;\r
+\r
+/* Set to an option character which was unrecognized.\r
+   This must be initialized on some systems to avoid linking in the\r
+   system's own getopt implementation.  */\r
+\r
+int optopt = '?';\r
+\r
+/* Describe how to deal with options that follow non-option ARGV-elements.\r
+\r
+   If the caller did not specify anything,\r
+   the default is REQUIRE_ORDER if the environment variable\r
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.\r
+\r
+   REQUIRE_ORDER means don't recognize them as options;\r
+   stop option processing when the first non-option is seen.\r
+   This is what Unix does.\r
+   This mode of operation is selected by either setting the environment\r
+   variable POSIXLY_CORRECT, or using `+' as the first character\r
+   of the list of option characters.\r
+\r
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,\r
+   so that eventually all the non-options are at the end.  This allows options\r
+   to be given in any order, even with programs that were not written to\r
+   expect this.\r
+\r
+   RETURN_IN_ORDER is an option available to programs that were written\r
+   to expect options and other ARGV-elements in any order and that care about\r
+   the ordering of the two.  We describe each non-option ARGV-element\r
+   as if it were the argument of an option with character code 1.\r
+   Using `-' as the first character of the list of option characters\r
+   selects this mode of operation.\r
+\r
+   The special argument `--' forces an end of option-scanning regardless\r
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only\r
+   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */\r
+\r
+static enum\r
+{\r
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER\r
+} ordering;\r
+\r
+/* Value of POSIXLY_CORRECT environment variable.  */\r
+static char *posixly_correct;\r
+\f\r
+#ifdef __GNU_LIBRARY__\r
+/* We want to avoid inclusion of string.h with non-GNU libraries\r
+   because there are many ways it can cause trouble.\r
+   On some systems, it contains special magic macros that don't work\r
+   in GCC.  */\r
+# include <string.h>\r
+# define my_index      strchr\r
+#else\r
+\r
+#include <string.h>\r
+\r
+/* Avoid depending on library functions or files\r
+   whose names are inconsistent.  */\r
+\r
+#ifndef getenv\r
+extern char *getenv ();\r
+#endif\r
+\r
+static char *\r
+my_index (str, chr)\r
+     const char *str;\r
+     int chr;\r
+{\r
+  while (*str)\r
+    {\r
+      if (*str == chr)\r
+       return (char *) str;\r
+      str++;\r
+    }\r
+  return 0;\r
+}\r
+\r
+/* If using GCC, we can safely declare strlen this way.\r
+   If not using GCC, it is ok not to declare it.  */\r
+#ifdef __GNUC__\r
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.\r
+   That was relevant to code that was here before.  */\r
+# if (!defined __STDC__ || !__STDC__) && !defined strlen\r
+/* gcc with -traditional declares the built-in strlen to return int,\r
+   and has done so at least since version 2.4.5. -- rms.  */\r
+extern int strlen (const char *);\r
+# endif /* not __STDC__ */\r
+#endif /* __GNUC__ */\r
+\r
+#endif /* not __GNU_LIBRARY__ */\r
+\f\r
+/* Handle permutation of arguments.  */\r
+\r
+/* Describe the part of ARGV that contains non-options that have\r
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;\r
+   `last_nonopt' is the index after the last of them.  */\r
+\r
+static int first_nonopt;\r
+static int last_nonopt;\r
+\r
+#ifdef _LIBC\r
+/* Bash 2.0 gives us an environment variable containing flags\r
+   indicating ARGV elements that should not be considered arguments.  */\r
+\r
+/* Defined in getopt_init.c  */\r
+extern char *__getopt_nonoption_flags;\r
+\r
+static int nonoption_flags_max_len;\r
+static int nonoption_flags_len;\r
+\r
+static int original_argc;\r
+static char *const *original_argv;\r
+\r
+/* Make sure the environment variable bash 2.0 puts in the environment\r
+   is valid for the getopt call we must make sure that the ARGV passed\r
+   to getopt is that one passed to the process.  */\r
+static void\r
+__attribute__ ((unused))\r
+store_args_and_env (int argc, char *const *argv)\r
+{\r
+  /* XXX This is no good solution.  We should rather copy the args so\r
+     that we can compare them later.  But we must not use malloc(3).  */\r
+  original_argc = argc;\r
+  original_argv = argv;\r
+}\r
+# ifdef text_set_element\r
+text_set_element (__libc_subinit, store_args_and_env);\r
+# endif /* text_set_element */\r
+\r
+# define SWAP_FLAGS(ch1, ch2) \\r
+  if (nonoption_flags_len > 0)                                               \\r
+    {                                                                        \\r
+      char __tmp = __getopt_nonoption_flags[ch1];                            \\r
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];         \\r
+      __getopt_nonoption_flags[ch2] = __tmp;                                 \\r
+    }\r
+#else  /* !_LIBC */\r
+# define SWAP_FLAGS(ch1, ch2)\r
+#endif /* _LIBC */\r
+\r
+/* Exchange two adjacent subsequences of ARGV.\r
+   One subsequence is elements [first_nonopt,last_nonopt)\r
+   which contains all the non-options that have been skipped so far.\r
+   The other is elements [last_nonopt,optind), which contains all\r
+   the options processed since those non-options were skipped.\r
+\r
+   `first_nonopt' and `last_nonopt' are relocated so that they describe\r
+   the new indices of the non-options in ARGV after they are moved.  */\r
+\r
+#if defined __STDC__ && __STDC__\r
+static void exchange (char **);\r
+#endif\r
+\r
+static void\r
+exchange (argv)\r
+     char **argv;\r
+{\r
+  int bottom = first_nonopt;\r
+  int middle = last_nonopt;\r
+  int top = optind;\r
+  char *tem;\r
+\r
+  /* Exchange the shorter segment with the far end of the longer segment.\r
+     That puts the shorter segment into the right place.\r
+     It leaves the longer segment in the right place overall,\r
+     but it consists of two parts that need to be swapped next.  */\r
+\r
+#ifdef _LIBC\r
+  /* First make sure the handling of the `__getopt_nonoption_flags'\r
+     string can work normally.  Our top argument must be in the range\r
+     of the string.  */\r
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)\r
+    {\r
+      /* We must extend the array.  The user plays games with us and\r
+        presents new arguments.  */\r
+      char *new_str = malloc (top + 1);\r
+      if (new_str == NULL)\r
+       nonoption_flags_len = nonoption_flags_max_len = 0;\r
+      else\r
+       {\r
+         memset (__mempcpy (new_str, __getopt_nonoption_flags,\r
+                            nonoption_flags_max_len),\r
+                 '\0', top + 1 - nonoption_flags_max_len);\r
+         nonoption_flags_max_len = top + 1;\r
+         __getopt_nonoption_flags = new_str;\r
+       }\r
+    }\r
+#endif\r
+\r
+  while (top > middle && middle > bottom)\r
+    {\r
+      if (top - middle > middle - bottom)\r
+       {\r
+         /* Bottom segment is the short one.  */\r
+         int len = middle - bottom;\r
+         register int i;\r
+\r
+         /* Swap it with the top part of the top segment.  */\r
+         for (i = 0; i < len; i++)\r
+           {\r
+             tem = argv[bottom + i];\r
+             argv[bottom + i] = argv[top - (middle - bottom) + i];\r
+             argv[top - (middle - bottom) + i] = tem;\r
+             SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);\r
+           }\r
+         /* Exclude the moved bottom segment from further swapping.  */\r
+         top -= len;\r
+       }\r
+      else\r
+       {\r
+         /* Top segment is the short one.  */\r
+         int len = top - middle;\r
+         register int i;\r
+\r
+         /* Swap it with the bottom part of the bottom segment.  */\r
+         for (i = 0; i < len; i++)\r
+           {\r
+             tem = argv[bottom + i];\r
+             argv[bottom + i] = argv[middle + i];\r
+             argv[middle + i] = tem;\r
+             SWAP_FLAGS (bottom + i, middle + i);\r
+           }\r
+         /* Exclude the moved top segment from further swapping.  */\r
+         bottom += len;\r
+       }\r
+    }\r
+\r
+  /* Update records for the slots the non-options now occupy.  */\r
+\r
+  first_nonopt += (optind - last_nonopt);\r
+  last_nonopt = optind;\r
+}\r
+\r
+/* Initialize the internal data when the first call is made.  */\r
+\r
+#if defined __STDC__ && __STDC__\r
+static const char *_getopt_initialize (int, char *const *, const char *);\r
+#endif\r
+static const char *\r
+_getopt_initialize (argc, argv, optstring)\r
+     int argc;\r
+     char *const *argv;\r
+     const char *optstring;\r
+{\r
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0\r
+     is the program name); the sequence of previously skipped\r
+     non-option ARGV-elements is empty.  */\r
+\r
+  first_nonopt = last_nonopt = optind;\r
+\r
+  nextchar = NULL;\r
+\r
+  posixly_correct = getenv ("POSIXLY_CORRECT");\r
+\r
+  /* Determine how to handle the ordering of options and nonoptions.  */\r
+\r
+  if (optstring[0] == '-')\r
+    {\r
+      ordering = RETURN_IN_ORDER;\r
+      ++optstring;\r
+    }\r
+  else if (optstring[0] == '+')\r
+    {\r
+      ordering = REQUIRE_ORDER;\r
+      ++optstring;\r
+    }\r
+  else if (posixly_correct != NULL)\r
+    ordering = REQUIRE_ORDER;\r
+  else\r
+    ordering = PERMUTE;\r
+\r
+#ifdef _LIBC\r
+  if (posixly_correct == NULL\r
+      && argc == original_argc && argv == original_argv)\r
+    {\r
+      if (nonoption_flags_max_len == 0)\r
+       {\r
+         if (__getopt_nonoption_flags == NULL\r
+             || __getopt_nonoption_flags[0] == '\0')\r
+           nonoption_flags_max_len = -1;\r
+         else\r
+           {\r
+             const char *orig_str = __getopt_nonoption_flags;\r
+             int len = nonoption_flags_max_len = strlen (orig_str);\r
+             if (nonoption_flags_max_len < argc)\r
+               nonoption_flags_max_len = argc;\r
+             __getopt_nonoption_flags =\r
+               (char *) malloc (nonoption_flags_max_len);\r
+             if (__getopt_nonoption_flags == NULL)\r
+               nonoption_flags_max_len = -1;\r
+             else\r
+               memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),\r
+                       '\0', nonoption_flags_max_len - len);\r
+           }\r
+       }\r
+      nonoption_flags_len = nonoption_flags_max_len;\r
+    }\r
+  else\r
+    nonoption_flags_len = 0;\r
+#endif\r
+\r
+  return optstring;\r
+}\r
+\f\r
+/* Scan elements of ARGV (whose length is ARGC) for option characters\r
+   given in OPTSTRING.\r
+\r
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",\r
+   then it is an option element.  The characters of this element\r
+   (aside from the initial '-') are option characters.  If `getopt'\r
+   is called repeatedly, it returns successively each of the option characters\r
+   from each of the option elements.\r
+\r
+   If `getopt' finds another option character, it returns that character,\r
+   updating `optind' and `nextchar' so that the next call to `getopt' can\r
+   resume the scan with the following option character or ARGV-element.\r
+\r
+   If there are no more option characters, `getopt' returns -1.\r
+   Then `optind' is the index in ARGV of the first ARGV-element\r
+   that is not an option.  (The ARGV-elements have been permuted\r
+   so that those that are not options now come last.)\r
+\r
+   OPTSTRING is a string containing the legitimate option characters.\r
+   If an option character is seen that is not listed in OPTSTRING,\r
+   return '?' after printing an error message.  If you set `opterr' to\r
+   zero, the error message is suppressed but we still return '?'.\r
+\r
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,\r
+   so the following text in the same ARGV-element, or the text of the following\r
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that\r
+   wants an optional arg; if there is text in the current ARGV-element,\r
+   it is returned in `optarg', otherwise `optarg' is set to zero.\r
+\r
+   If OPTSTRING starts with `-' or `+', it requests different methods of\r
+   handling the non-option ARGV-elements.\r
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.\r
+\r
+   Long-named options begin with `--' instead of `-'.\r
+   Their names may be abbreviated as long as the abbreviation is unique\r
+   or is an exact match for some defined option.  If they have an\r
+   argument, it follows the option name in the same ARGV-element, separated\r
+   from the option name by a `=', or else the in next ARGV-element.\r
+   When `getopt' finds a long-named option, it returns 0 if that option's\r
+   `flag' field is nonzero, the value of the option's `val' field\r
+   if the `flag' field is zero.\r
+\r
+   The elements of ARGV aren't really const, because we permute them.\r
+   But we pretend they're const in the prototype to be compatible\r
+   with other systems.\r
+\r
+   LONGOPTS is a vector of `struct option' terminated by an\r
+   element containing a name which is zero.\r
+\r
+   LONGIND returns the index in LONGOPT of the long-named option found.\r
+   It is only valid when a long-named option has been found by the most\r
+   recent call.\r
+\r
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce\r
+   long-named options.  */\r
+\r
+int\r
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)\r
+     int argc;\r
+     char *const *argv;\r
+     const char *optstring;\r
+     const struct option *longopts;\r
+     int *longind;\r
+     int long_only;\r
+{\r
+  optarg = NULL;\r
+\r
+  if (optind == 0 || !__getopt_initialized)\r
+    {\r
+      if (optind == 0)\r
+       optind = 1;     /* Don't scan ARGV[0], the program name.  */\r
+      optstring = _getopt_initialize (argc, argv, optstring);\r
+      __getopt_initialized = 1;\r
+    }\r
+\r
+  /* Test whether ARGV[optind] points to a non-option argument.\r
+     Either it does not have option syntax, or there is an environment flag\r
+     from the shell indicating it is not an option.  The later information\r
+     is only used when the used in the GNU libc.  */\r
+#ifdef _LIBC\r
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'              \\r
+                     || (optind < nonoption_flags_len                        \\r
+                         && __getopt_nonoption_flags[optind] == '1'))\r
+#else\r
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')\r
+#endif\r
+\r
+  if (nextchar == NULL || *nextchar == '\0')\r
+    {\r
+      /* Advance to the next ARGV-element.  */\r
+\r
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been\r
+        moved back by the user (who may also have changed the arguments).  */\r
+      if (last_nonopt > optind)\r
+       last_nonopt = optind;\r
+      if (first_nonopt > optind)\r
+       first_nonopt = optind;\r
+\r
+      if (ordering == PERMUTE)\r
+       {\r
+         /* If we have just processed some options following some non-options,\r
+            exchange them so that the options come first.  */\r
+\r
+         if (first_nonopt != last_nonopt && last_nonopt != optind)\r
+           exchange ((char **) argv);\r
+         else if (last_nonopt != optind)\r
+           first_nonopt = optind;\r
+\r
+         /* Skip any additional non-options\r
+            and extend the range of non-options previously skipped.  */\r
+\r
+         while (optind < argc && NONOPTION_P)\r
+           optind++;\r
+         last_nonopt = optind;\r
+       }\r
+\r
+      /* The special ARGV-element `--' means premature end of options.\r
+        Skip it like a null option,\r
+        then exchange with previous non-options as if it were an option,\r
+        then skip everything else like a non-option.  */\r
+\r
+      if (optind != argc && !strcmp (argv[optind], "--"))\r
+       {\r
+         optind++;\r
+\r
+         if (first_nonopt != last_nonopt && last_nonopt != optind)\r
+           exchange ((char **) argv);\r
+         else if (first_nonopt == last_nonopt)\r
+           first_nonopt = optind;\r
+         last_nonopt = argc;\r
+\r
+         optind = argc;\r
+       }\r
+\r
+      /* If we have done all the ARGV-elements, stop the scan\r
+        and back over any non-options that we skipped and permuted.  */\r
+\r
+      if (optind == argc)\r
+       {\r
+         /* Set the next-arg-index to point at the non-options\r
+            that we previously skipped, so the caller will digest them.  */\r
+         if (first_nonopt != last_nonopt)\r
+           optind = first_nonopt;\r
+         return -1;\r
+       }\r
+\r
+      /* If we have come to a non-option and did not permute it,\r
+        either stop the scan or describe it to the caller and pass it by.  */\r
+\r
+      if (NONOPTION_P)\r
+       {\r
+         if (ordering == REQUIRE_ORDER)\r
+           return -1;\r
+         optarg = argv[optind++];\r
+         return 1;\r
+       }\r
+\r
+      /* We have found another option-ARGV-element.\r
+        Skip the initial punctuation.  */\r
+\r
+      nextchar = (argv[optind] + 1\r
+                 + (longopts != NULL && argv[optind][1] == '-'));\r
+    }\r
+\r
+  /* Decode the current option-ARGV-element.  */\r
+\r
+  /* Check whether the ARGV-element is a long option.\r
+\r
+     If long_only and the ARGV-element has the form "-f", where f is\r
+     a valid short option, don't consider it an abbreviated form of\r
+     a long option that starts with f.  Otherwise there would be no\r
+     way to give the -f short option.\r
+\r
+     On the other hand, if there's a long option "fubar" and\r
+     the ARGV-element is "-fu", do consider that an abbreviation of\r
+     the long option, just like "--fu", and not "-f" with arg "u".\r
+\r
+     This distinction seems to be the most useful approach.  */\r
+\r
+  if (longopts != NULL\r
+      && (argv[optind][1] == '-'\r
+         || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))\r
+    {\r
+      char *nameend;\r
+      const struct option *p;\r
+      const struct option *pfound = NULL;\r
+      int exact = 0;\r
+      int ambig = 0;\r
+      int indfound = -1;\r
+      int option_index;\r
+\r
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)\r
+       /* Do nothing.  */ ;\r
+\r
+      /* Test all long options for either exact match\r
+        or abbreviated matches.  */\r
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)\r
+       if (!strncmp (p->name, nextchar, nameend - nextchar))\r
+         {\r
+           if ((unsigned int) (nameend - nextchar)\r
+               == (unsigned int) strlen (p->name))\r
+             {\r
+               /* Exact match found.  */\r
+               pfound = p;\r
+               indfound = option_index;\r
+               exact = 1;\r
+               break;\r
+             }\r
+           else if (pfound == NULL)\r
+             {\r
+               /* First nonexact match found.  */\r
+               pfound = p;\r
+               indfound = option_index;\r
+             }\r
+           else\r
+             /* Second or later nonexact match found.  */\r
+             ambig = 1;\r
+         }\r
+\r
+      if (ambig && !exact)\r
+       {\r
+         if (opterr)\r
+           fprintf (stderr, _("%s: option `%s' is ambiguous\n"),\r
+                    argv[0], argv[optind]);\r
+         nextchar += strlen (nextchar);\r
+         optind++;\r
+         optopt = 0;\r
+         return '?';\r
+       }\r
+\r
+      if (pfound != NULL)\r
+       {\r
+         option_index = indfound;\r
+         optind++;\r
+         if (*nameend)\r
+           {\r
+             /* Don't test has_arg with >, because some C compilers don't\r
+                allow it to be used on enums.  */\r
+             if (pfound->has_arg)\r
+               optarg = nameend + 1;\r
+             else\r
+               {\r
+                 if (opterr)\r
+                   {\r
+                     if (argv[optind - 1][1] == '-')\r
+                       /* --option */\r
+                       fprintf (stderr,\r
+                                _("%s: option `--%s' doesn't allow an argument\n"),\r
+                                argv[0], pfound->name);\r
+                     else\r
+                       /* +option or -option */\r
+                       fprintf (stderr,\r
+                                _("%s: option `%c%s' doesn't allow an argument\n"),\r
+                                argv[0], argv[optind - 1][0], pfound->name);\r
+                   }\r
+\r
+                 nextchar += strlen (nextchar);\r
+\r
+                 optopt = pfound->val;\r
+                 return '?';\r
+               }\r
+           }\r
+         else if (pfound->has_arg == 1)\r
+           {\r
+             if (optind < argc)\r
+               optarg = argv[optind++];\r
+             else\r
+               {\r
+                 if (opterr)\r
+                   fprintf (stderr,\r
+                          _("%s: option `%s' requires an argument\n"),\r
+                          argv[0], argv[optind - 1]);\r
+                 nextchar += strlen (nextchar);\r
+                 optopt = pfound->val;\r
+                 return optstring[0] == ':' ? ':' : '?';\r
+               }\r
+           }\r
+         nextchar += strlen (nextchar);\r
+         if (longind != NULL)\r
+           *longind = option_index;\r
+         if (pfound->flag)\r
+           {\r
+             *(pfound->flag) = pfound->val;\r
+             return 0;\r
+           }\r
+         return pfound->val;\r
+       }\r
+\r
+      /* Can't find it as a long option.  If this is not getopt_long_only,\r
+        or the option starts with '--' or is not a valid short\r
+        option, then it's an error.\r
+        Otherwise interpret it as a short option.  */\r
+      if (!long_only || argv[optind][1] == '-'\r
+         || my_index (optstring, *nextchar) == NULL)\r
+       {\r
+         if (opterr)\r
+           {\r
+             if (argv[optind][1] == '-')\r
+               /* --option */\r
+               fprintf (stderr, _("%s: unrecognized option `--%s'\n"),\r
+                        argv[0], nextchar);\r
+             else\r
+               /* +option or -option */\r
+               fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),\r
+                        argv[0], argv[optind][0], nextchar);\r
+           }\r
+         nextchar = (char *) "";\r
+         optind++;\r
+         optopt = 0;\r
+         return '?';\r
+       }\r
+    }\r
+\r
+  /* Look at and handle the next short option-character.  */\r
+\r
+  {\r
+    char c = *nextchar++;\r
+    char *temp = my_index (optstring, c);\r
+\r
+    /* Increment `optind' when we start to process its last character.  */\r
+    if (*nextchar == '\0')\r
+      ++optind;\r
+\r
+    if (temp == NULL || c == ':')\r
+      {\r
+       if (opterr)\r
+         {\r
+           if (posixly_correct)\r
+             /* 1003.2 specifies the format of this message.  */\r
+             fprintf (stderr, _("%s: illegal option -- %c\n"),\r
+                      argv[0], c);\r
+           else\r
+             fprintf (stderr, _("%s: invalid option -- %c\n"),\r
+                      argv[0], c);\r
+         }\r
+       optopt = c;\r
+       return '?';\r
+      }\r
+    /* Convenience. Treat POSIX -W foo same as long option --foo */\r
+    if (temp[0] == 'W' && temp[1] == ';')\r
+      {\r
+       char *nameend;\r
+       const struct option *p;\r
+       const struct option *pfound = NULL;\r
+       int exact = 0;\r
+       int ambig = 0;\r
+       int indfound = 0;\r
+       int option_index;\r
+\r
+       /* This is an option that requires an argument.  */\r
+       if (*nextchar != '\0')\r
+         {\r
+           optarg = nextchar;\r
+           /* If we end this ARGV-element by taking the rest as an arg,\r
+              we must advance to the next element now.  */\r
+           optind++;\r
+         }\r
+       else if (optind == argc)\r
+         {\r
+           if (opterr)\r
+             {\r
+               /* 1003.2 specifies the format of this message.  */\r
+               fprintf (stderr, _("%s: option requires an argument -- %c\n"),\r
+                        argv[0], c);\r
+             }\r
+           optopt = c;\r
+           if (optstring[0] == ':')\r
+             c = ':';\r
+           else\r
+             c = '?';\r
+           return c;\r
+         }\r
+       else\r
+         /* We already incremented `optind' once;\r
+            increment it again when taking next ARGV-elt as argument.  */\r
+         optarg = argv[optind++];\r
+\r
+       /* optarg is now the argument, see if it's in the\r
+          table of longopts.  */\r
+\r
+       for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)\r
+         /* Do nothing.  */ ;\r
+\r
+       /* Test all long options for either exact match\r
+          or abbreviated matches.  */\r
+       for (p = longopts, option_index = 0; p->name; p++, option_index++)\r
+         if (!strncmp (p->name, nextchar, nameend - nextchar))\r
+           {\r
+             if ((unsigned int) (nameend - nextchar) == strlen (p->name))\r
+               {\r
+                 /* Exact match found.  */\r
+                 pfound = p;\r
+                 indfound = option_index;\r
+                 exact = 1;\r
+                 break;\r
+               }\r
+             else if (pfound == NULL)\r
+               {\r
+                 /* First nonexact match found.  */\r
+                 pfound = p;\r
+                 indfound = option_index;\r
+               }\r
+             else\r
+               /* Second or later nonexact match found.  */\r
+               ambig = 1;\r
+           }\r
+       if (ambig && !exact)\r
+         {\r
+           if (opterr)\r
+             fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),\r
+                      argv[0], argv[optind]);\r
+           nextchar += strlen (nextchar);\r
+           optind++;\r
+           return '?';\r
+         }\r
+       if (pfound != NULL)\r
+         {\r
+           option_index = indfound;\r
+           if (*nameend)\r
+             {\r
+               /* Don't test has_arg with >, because some C compilers don't\r
+                  allow it to be used on enums.  */\r
+               if (pfound->has_arg)\r
+                 optarg = nameend + 1;\r
+               else\r
+                 {\r
+                   if (opterr)\r
+                     fprintf (stderr, _("\\r
+%s: option `-W %s' doesn't allow an argument\n"),\r
+                              argv[0], pfound->name);\r
+\r
+                   nextchar += strlen (nextchar);\r
+                   return '?';\r
+                 }\r
+             }\r
+           else if (pfound->has_arg == 1)\r
+             {\r
+               if (optind < argc)\r
+                 optarg = argv[optind++];\r
+               else\r
+                 {\r
+                   if (opterr)\r
+                     fprintf (stderr,\r
+                              _("%s: option `%s' requires an argument\n"),\r
+                              argv[0], argv[optind - 1]);\r
+                   nextchar += strlen (nextchar);\r
+                   return optstring[0] == ':' ? ':' : '?';\r
+                 }\r
+             }\r
+           nextchar += strlen (nextchar);\r
+           if (longind != NULL)\r
+             *longind = option_index;\r
+           if (pfound->flag)\r
+             {\r
+               *(pfound->flag) = pfound->val;\r
+               return 0;\r
+             }\r
+           return pfound->val;\r
+         }\r
+         nextchar = NULL;\r
+         return 'W';   /* Let the application handle it.   */\r
+      }\r
+    if (temp[1] == ':')\r
+      {\r
+       if (temp[2] == ':')\r
+         {\r
+           /* This is an option that accepts an argument optionally.  */\r
+           if (*nextchar != '\0')\r
+             {\r
+               optarg = nextchar;\r
+               optind++;\r
+             }\r
+           else\r
+             optarg = NULL;\r
+           nextchar = NULL;\r
+         }\r
+       else\r
+         {\r
+           /* This is an option that requires an argument.  */\r
+           if (*nextchar != '\0')\r
+             {\r
+               optarg = nextchar;\r
+               /* If we end this ARGV-element by taking the rest as an arg,\r
+                  we must advance to the next element now.  */\r
+               optind++;\r
+             }\r
+           else if (optind == argc)\r
+             {\r
+               if (opterr)\r
+                 {\r
+                   /* 1003.2 specifies the format of this message.  */\r
+                   fprintf (stderr,\r
+                          _("%s: option requires an argument -- %c\n"),\r
+                          argv[0], c);\r
+                 }\r
+               optopt = c;\r
+               if (optstring[0] == ':')\r
+                 c = ':';\r
+               else\r
+                 c = '?';\r
+             }\r
+           else\r
+             /* We already incremented `optind' once;\r
+                increment it again when taking next ARGV-elt as argument.  */\r
+             optarg = argv[optind++];\r
+           nextchar = NULL;\r
+         }\r
+      }\r
+    return c;\r
+  }\r
+}\r
+\r
+int\r
+getopt (argc, argv, optstring)\r
+     int argc;\r
+     char *const *argv;\r
+     const char *optstring;\r
+{\r
+  return _getopt_internal (argc, argv, optstring,\r
+                          (const struct option *) 0,\r
+                          (int *) 0,\r
+                          0);\r
+}\r
+\r
+#endif /* Not ELIDE_CODE.  */\r
+\f\r
+#ifdef TEST\r
+\r
+/* Compile with -DTEST to make an executable for use in testing\r
+   the above definition of `getopt'.  */\r
+\r
+int\r
+main (argc, argv)\r
+     int argc;\r
+     char **argv;\r
+{\r
+  int c;\r
+  int digit_optind = 0;\r
+\r
+  while (1)\r
+    {\r
+      int this_option_optind = optind ? optind : 1;\r
+\r
+      c = getopt (argc, argv, "abc:d:0123456789");\r
+      if (c == -1)\r
+       break;\r
+\r
+      switch (c)\r
+       {\r
+       case '0':\r
+       case '1':\r
+       case '2':\r
+       case '3':\r
+       case '4':\r
+       case '5':\r
+       case '6':\r
+       case '7':\r
+       case '8':\r
+       case '9':\r
+         if (digit_optind != 0 && digit_optind != this_option_optind)\r
+           printf ("digits occur in two different argv-elements.\n");\r
+         digit_optind = this_option_optind;\r
+         printf ("option %c\n", c);\r
+         break;\r
+\r
+       case 'a':\r
+         printf ("option a\n");\r
+         break;\r
+\r
+       case 'b':\r
+         printf ("option b\n");\r
+         break;\r
+\r
+       case 'c':\r
+         printf ("option c with value `%s'\n", optarg);\r
+         break;\r
+\r
+       case '?':\r
+         break;\r
+\r
+       default:\r
+         printf ("?? getopt returned character code 0%o ??\n", c);\r
+       }\r
+    }\r
+\r
+  if (optind < argc)\r
+    {\r
+      printf ("non-option ARGV-elements: ");\r
+      while (optind < argc)\r
+       printf ("%s ", argv[optind++]);\r
+      printf ("\n");\r
+    }\r
+\r
+  exit (0);\r
+}\r
+\r
+#endif /* TEST */\r
diff --git a/tools/getopt1.c b/tools/getopt1.c
new file mode 100644 (file)
index 0000000..39f8383
--- /dev/null
@@ -0,0 +1,188 @@
+/* getopt_long and getopt_long_only entry points for GNU getopt.\r
+   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98\r
+     Free Software Foundation, Inc.\r
+   This file is part of the GNU C Library.\r
+\r
+   The GNU C Library is free software; you can redistribute it and/or\r
+   modify it under the terms of the GNU Library General Public License as\r
+   published by the Free Software Foundation; either version 2 of the\r
+   License, or (at your option) any later version.\r
+\r
+   The GNU C Library is distributed in the hope that it will be useful,\r
+   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+   Library General Public License for more details.\r
+\r
+   You should have received a copy of the GNU Library General Public\r
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,\r
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
+   Boston, MA 02111-1307, USA.  */\r
+\r
+#ifdef HAVE_CONFIG_H\r
+#include "config.h"\r
+#endif\r
+\r
+#include "getopt_win.h"\r
+\r
+#if !defined __STDC__ || !__STDC__\r
+/* This is a separate conditional since some stdc systems\r
+   reject `defined (const)'.  */\r
+#ifndef const\r
+#define const\r
+#endif\r
+#endif\r
+\r
+#include <stdio.h>\r
+\r
+/* Comment out all this code if we are using the GNU C Library, and are not\r
+   actually compiling the library itself.  This code is part of the GNU C\r
+   Library, but also included in many other GNU distributions.  Compiling\r
+   and linking in this code is a waste when using the GNU C library\r
+   (especially if it is a shared library).  Rather than having every GNU\r
+   program understand `configure --with-gnu-libc' and omit the object files,\r
+   it is simpler to just do this in the source for each such file.  */\r
+\r
+#define GETOPT_INTERFACE_VERSION 2\r
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2\r
+#include <gnu-versions.h>\r
+#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION\r
+#define ELIDE_CODE\r
+#endif\r
+#endif\r
+\r
+#ifndef ELIDE_CODE\r
+\r
+\r
+/* This needs to come after some library #include\r
+   to get __GNU_LIBRARY__ defined.  */\r
+#ifdef __GNU_LIBRARY__\r
+#include <stdlib.h>\r
+#endif\r
+\r
+#ifndef        NULL\r
+#define NULL 0\r
+#endif\r
+\r
+int\r
+getopt_long (argc, argv, options, long_options, opt_index)\r
+     int argc;\r
+     char *const *argv;\r
+     const char *options;\r
+     const struct option *long_options;\r
+     int *opt_index;\r
+{\r
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);\r
+}\r
+\r
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.\r
+   If an option that starts with '-' (not '--') doesn't match a long option,\r
+   but does match a short option, it is parsed as a short option\r
+   instead.  */\r
+\r
+int\r
+getopt_long_only (argc, argv, options, long_options, opt_index)\r
+     int argc;\r
+     char *const *argv;\r
+     const char *options;\r
+     const struct option *long_options;\r
+     int *opt_index;\r
+{\r
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);\r
+}\r
+\r
+\r
+#endif /* Not ELIDE_CODE.  */\r
+\f\r
+#ifdef TEST\r
+\r
+#include <stdio.h>\r
+\r
+int\r
+main (argc, argv)\r
+     int argc;\r
+     char **argv;\r
+{\r
+  int c;\r
+  int digit_optind = 0;\r
+\r
+  while (1)\r
+    {\r
+      int this_option_optind = optind ? optind : 1;\r
+      int option_index = 0;\r
+      static struct option long_options[] =\r
+      {\r
+       {"add", 1, 0, 0},\r
+       {"append", 0, 0, 0},\r
+       {"delete", 1, 0, 0},\r
+       {"verbose", 0, 0, 0},\r
+       {"create", 0, 0, 0},\r
+       {"file", 1, 0, 0},\r
+       {0, 0, 0, 0}\r
+      };\r
+\r
+      c = getopt_long (argc, argv, "abc:d:0123456789",\r
+                      long_options, &option_index);\r
+      if (c == -1)\r
+       break;\r
+\r
+      switch (c)\r
+       {\r
+       case 0:\r
+         printf ("option %s", long_options[option_index].name);\r
+         if (optarg)\r
+           printf (" with arg %s", optarg);\r
+         printf ("\n");\r
+         break;\r
+\r
+       case '0':\r
+       case '1':\r
+       case '2':\r
+       case '3':\r
+       case '4':\r
+       case '5':\r
+       case '6':\r
+       case '7':\r
+       case '8':\r
+       case '9':\r
+         if (digit_optind != 0 && digit_optind != this_option_optind)\r
+           printf ("digits occur in two different argv-elements.\n");\r
+         digit_optind = this_option_optind;\r
+         printf ("option %c\n", c);\r
+         break;\r
+\r
+       case 'a':\r
+         printf ("option a\n");\r
+         break;\r
+\r
+       case 'b':\r
+         printf ("option b\n");\r
+         break;\r
+\r
+       case 'c':\r
+         printf ("option c with value `%s'\n", optarg);\r
+         break;\r
+\r
+       case 'd':\r
+         printf ("option d with value `%s'\n", optarg);\r
+         break;\r
+\r
+       case '?':\r
+         break;\r
+\r
+       default:\r
+         printf ("?? getopt returned character code 0%o ??\n", c);\r
+       }\r
+    }\r
+\r
+  if (optind < argc)\r
+    {\r
+      printf ("non-option ARGV-elements: ");\r
+      while (optind < argc)\r
+       printf ("%s ", argv[optind++]);\r
+      printf ("\n");\r
+    }\r
+\r
+  exit (0);\r
+}\r
+\r
+#endif /* TEST */\r
diff --git a/tools/getopt_win.h b/tools/getopt_win.h
new file mode 100644 (file)
index 0000000..91eb54e
--- /dev/null
@@ -0,0 +1,169 @@
+/* Declarations for getopt.\r
+   Copyright (C) 1989,90,91,92,93,94,96,97,98 Free Software Foundation, Inc.\r
+   This file is part of the GNU C Library.\r
+\r
+   The GNU C Library is free software; you can redistribute it and/or\r
+   modify it under the terms of the GNU Library General Public License as\r
+   published by the Free Software Foundation; either version 2 of the\r
+   License, or (at your option) any later version.\r
+\r
+   The GNU C Library is distributed in the hope that it will be useful,\r
+   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+   Library General Public License for more details.\r
+\r
+   You should have received a copy of the GNU Library General Public\r
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,\r
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
+   Boston, MA 02111-1307, USA.  */\r
+\r
+#ifndef _GETOPT_H\r
+\r
+#ifndef __need_getopt\r
+# define _GETOPT_H 1\r
+#endif\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/* For communication from `getopt' to the caller.\r
+   When `getopt' finds an option that takes an argument,\r
+   the argument value is returned here.\r
+   Also, when `ordering' is RETURN_IN_ORDER,\r
+   each non-option ARGV-element is returned here.  */\r
+\r
+extern char *optarg;\r
+\r
+/* Index in ARGV of the next element to be scanned.\r
+   This is used for communication to and from the caller\r
+   and for communication between successive calls to `getopt'.\r
+\r
+   On entry to `getopt', zero means this is the first call; initialize.\r
+\r
+   When `getopt' returns -1, this is the index of the first of the\r
+   non-option elements that the caller should itself scan.\r
+\r
+   Otherwise, `optind' communicates from one call to the next\r
+   how much of ARGV has been scanned so far.  */\r
+\r
+extern int optind;\r
+\r
+/* Callers store zero here to inhibit the error message `getopt' prints\r
+   for unrecognized options.  */\r
+\r
+extern int opterr;\r
+\r
+/* Set to an option character which was unrecognized.  */\r
+\r
+extern int optopt;\r
+\r
+#ifndef __need_getopt\r
+/* Describe the long-named options requested by the application.\r
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector\r
+   of `struct option' terminated by an element containing a name which is\r
+   zero.\r
+\r
+   The field `has_arg' is:\r
+   no_argument         (or 0) if the option does not take an argument,\r
+   required_argument   (or 1) if the option requires an argument,\r
+   optional_argument   (or 2) if the option takes an optional argument.\r
+\r
+   If the field `flag' is not NULL, it points to a variable that is set\r
+   to the value given in the field `val' when the option is found, but\r
+   left unchanged if the option is not found.\r
+\r
+   To have a long-named option do something other than set an `int' to\r
+   a compiled-in constant, such as set a value from `optarg', set the\r
+   option's `flag' field to zero and its `val' field to a nonzero\r
+   value (the equivalent single-letter option character, if there is\r
+   one).  For long options that have a zero `flag' field, `getopt'\r
+   returns the contents of the `val' field.  */\r
+\r
+struct option\r
+{\r
+# if defined __STDC__ && __STDC__\r
+  const char *name;\r
+# else\r
+  char *name;\r
+# endif\r
+  /* has_arg can't be an enum because some compilers complain about\r
+     type mismatches in all the code that assumes it is an int.  */\r
+  int has_arg;\r
+  int *flag;\r
+  int val;\r
+};\r
+\r
+/* Names for the values of the `has_arg' field of `struct option'.  */\r
+\r
+# define no_argument           0\r
+# define required_argument     1\r
+# define optional_argument     2\r
+#endif /* need getopt */\r
+\r
+\r
+/* Get definitions and prototypes for functions to process the\r
+   arguments in ARGV (ARGC of them, minus the program name) for\r
+   options given in OPTS.\r
+\r
+   Return the option character from OPTS just read.  Return -1 when\r
+   there are no more options.  For unrecognized options, or options\r
+   missing arguments, `optopt' is set to the option letter, and '?' is\r
+   returned.\r
+\r
+   The OPTS string is a list of characters which are recognized option\r
+   letters, optionally followed by colons, specifying that that letter\r
+   takes an argument, to be placed in `optarg'.\r
+\r
+   If a letter in OPTS is followed by two colons, its argument is\r
+   optional.  This behavior is specific to the GNU `getopt'.\r
+\r
+   The argument `--' causes premature termination of argument\r
+   scanning, explicitly telling `getopt' that there are no more\r
+   options.\r
+\r
+   If OPTS begins with `--', then non-option arguments are treated as\r
+   arguments to the option '\0'.  This behavior is specific to the GNU\r
+   `getopt'.  */\r
+\r
+#if defined __STDC__ && __STDC__\r
+# ifdef __GNU_LIBRARY__\r
+/* Many other libraries have conflicting prototypes for getopt, with\r
+   differences in the consts, in stdlib.h.  To avoid compilation\r
+   errors, only prototype getopt for the GNU C library.  */\r
+extern int getopt (int __argc, char *const *__argv, const char *__shortopts);\r
+# else /* not __GNU_LIBRARY__ */\r
+extern int getopt ();\r
+# endif /* __GNU_LIBRARY__ */\r
+\r
+# ifndef __need_getopt\r
+extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,\r
+                       const struct option *__longopts, int *__longind);\r
+extern int getopt_long_only (int __argc, char *const *__argv,\r
+                            const char *__shortopts,\r
+                            const struct option *__longopts, int *__longind);\r
+\r
+/* Internal only.  Users should not call this directly.  */\r
+extern int _getopt_internal (int __argc, char *const *__argv,\r
+                            const char *__shortopts,\r
+                            const struct option *__longopts, int *__longind,\r
+                            int __long_only);\r
+# endif\r
+#else /* not __STDC__ */\r
+extern int getopt ();\r
+# ifndef __need_getopt\r
+extern int getopt_long ();\r
+extern int getopt_long_only ();\r
+\r
+extern int _getopt_internal ();\r
+# endif\r
+#endif /* __STDC__ */\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+/* Make sure we later can get all the definitions and declarations.  */\r
+#undef __need_getopt\r
+\r
+#endif /* getopt.h */\r
diff --git a/tools/wave_out.c b/tools/wave_out.c
new file mode 100644 (file)
index 0000000..64eeb6e
--- /dev/null
@@ -0,0 +1,220 @@
+/* Copyright (c) 2002, John Edwards\r
+\r
+   Redistribution and use in source and binary forms, with or without\r
+   modification, are permitted provided that the following conditions\r
+   are met:\r
+\r
+   - Redistributions of source code must retain the above copyright\r
+   notice, this list of conditions and the following disclaimer.\r
+\r
+   - Redistributions in binary form must reproduce the above copyright\r
+   notice, this list of conditions and the following disclaimer in the\r
+   documentation and/or other materials provided with the distribution.\r
+\r
+   - Neither the name of the Xiph.org Foundation nor the names of its\r
+   contributors may be used to endorse or promote products derived from\r
+   this software without specific prior written permission.\r
+\r
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR\r
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\r
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\r
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+*/\r
+\r
+#ifdef HAVE_CONFIG_H\r
+# include "config.h"\r
+#endif\r
+\r
+/* Set TABS = 4 */\r
+/********************************************************************\r
+\r
+ function: To provide playback of 16 bit PCM wave data in Win32\r
+           environments from decoded compressed files.\r
+\r
+ ********************************************************************/\r
+\r
+#if defined WIN32 || defined _WIN32\r
+\r
+#include <string.h>\r
+#include <errno.h>\r
+#include "wave_out.h"\r
+\r
+#define MAXWAVESIZE     4294967040LU\r
+#define MAX_WAVEBLOCKS    32\r
+\r
+// This is modified for USE_WIN_AUDIO - ONLY 2002-02-27\r
+\r
+\r
+static CRITICAL_SECTION  cs;\r
+static HWAVEOUT          dev                    = NULL;\r
+static int               ScheduledBlocks        = 0;\r
+static int               PlayedWaveHeadersCount = 0;          // free index\r
+static WAVEHDR*          PlayedWaveHeaders [MAX_WAVEBLOCKS];\r
+\r
+static int\r
+Box ( const char* msg )\r
+{\r
+       MessageBox ( NULL, msg, " "VERSION_STRING": Error Message . . .", MB_OK | MB_ICONEXCLAMATION );\r
+       return -1;\r
+}\r
+\r
+\r
+/*\r
+ *  This function registers already played WAVE chunks. Freeing is done by free_memory(),\r
+ */\r
+\r
+static void CALLBACK\r
+wave_callback ( HWAVE hWave, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )\r
+{\r
+       if ( uMsg == WOM_DONE ) {\r
+               EnterCriticalSection ( &cs );\r
+               PlayedWaveHeaders [PlayedWaveHeadersCount++] = (WAVEHDR*) dwParam1;\r
+               LeaveCriticalSection ( &cs );\r
+       }\r
+}\r
+\r
+\r
+static void\r
+free_memory ( void )\r
+{\r
+       WAVEHDR*  wh;\r
+       HGLOBAL   hg;\r
+\r
+       EnterCriticalSection ( &cs );\r
+       wh = PlayedWaveHeaders [--PlayedWaveHeadersCount];\r
+       ScheduledBlocks--;                               // decrease the number of USED blocks\r
+       LeaveCriticalSection ( &cs );\r
+\r
+       waveOutUnprepareHeader ( dev, wh, sizeof (WAVEHDR) );\r
+\r
+       hg = GlobalHandle ( wh -> lpData );       // Deallocate the buffer memory\r
+       GlobalUnlock (hg);\r
+       GlobalFree   (hg);\r
+\r
+       hg = GlobalHandle ( wh );                 // Deallocate the header memory\r
+       GlobalUnlock (hg);\r
+       GlobalFree   (hg);\r
+}\r
+\r
+\r
+Int\r
+Set_WIN_Params ( FILE_T   dummyFile ,\r
+                 Ldouble  SampleFreq,\r
+                 Uint     BitsPerSample,\r
+                 Uint     Channels )\r
+{\r
+       WAVEFORMATEX  outFormat;\r
+       UINT          deviceID = WAVE_MAPPER;\r
+\r
+       (void) dummyFile;\r
+\r
+       if ( waveOutGetNumDevs () == 0 )\r
+               return Box ( "No audio device present." );\r
+\r
+       outFormat.wFormatTag      = WAVE_FORMAT_PCM;\r
+       outFormat.wBitsPerSample  = BitsPerSample;\r
+       outFormat.nChannels       = Channels;\r
+       outFormat.nSamplesPerSec  = (unsigned long)(SampleFreq + 0.5);\r
+       outFormat.nBlockAlign     = (outFormat.wBitsPerSample + 7) / 8 * outFormat.nChannels;\r
+       outFormat.nAvgBytesPerSec = outFormat.nSamplesPerSec * outFormat.nBlockAlign;\r
+\r
+       switch ( waveOutOpen ( &dev, deviceID, &outFormat, (DWORD)wave_callback, 0, CALLBACK_FUNCTION ) )\r
+       {\r
+               case MMSYSERR_ALLOCATED:   return Box ( "Device is already open." );\r
+               case MMSYSERR_BADDEVICEID: return Box ( "The specified device is out of range." );\r
+               case MMSYSERR_NODRIVER:    return Box ( "There is no audio driver in this system." );\r
+               case MMSYSERR_NOMEM:       return Box ( "Unable to allocate sound memory." );\r
+               case WAVERR_BADFORMAT:     return Box ( "This audio format is not supported." );\r
+               case WAVERR_SYNC:          return Box ( "The device is synchronous." );\r
+               default:                   return Box ( "Unknown media error." );\r
+               case MMSYSERR_NOERROR:     break;\r
+       }\r
+\r
+       waveOutReset ( dev );\r
+       InitializeCriticalSection ( &cs );\r
+       SetPriorityClass ( GetCurrentProcess (), HIGH_PRIORITY_CLASS );\r
+       return 0;\r
+}\r
+\r
+\r
+int\r
+WIN_Play_Samples ( const void* data, size_t len )\r
+{\r
+       HGLOBAL    hg;\r
+       HGLOBAL    hg2;\r
+       LPWAVEHDR  wh;\r
+       void*      allocptr;\r
+\r
+       do {\r
+               while ( PlayedWaveHeadersCount > 0 )                // free used blocks ...\r
+                       free_memory ();\r
+\r
+               if ( ScheduledBlocks < sizeof(PlayedWaveHeaders)/sizeof(*PlayedWaveHeaders) ) // wait for a free block ...\r
+                       break;\r
+               Sleep (26);\r
+       } while (1);\r
+\r
+       if ( (hg2 = GlobalAlloc ( GMEM_MOVEABLE, len )) == NULL )   // allocate some memory for a copy of the buffer\r
+               return Box ( "GlobalAlloc failed." );\r
+\r
+       allocptr = GlobalLock (hg2);\r
+       CopyMemory ( allocptr, data, len );                         // Here we can call any modification output functions we want....\r
+\r
+       if ( (hg = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof (WAVEHDR))) == NULL ) // now make a header and WRITE IT!\r
+               return -1;\r
+\r
+       wh                   = GlobalLock (hg);\r
+       wh -> dwBufferLength = len;\r
+       wh -> lpData         = allocptr;\r
+\r
+       if ( waveOutPrepareHeader ( dev, wh, sizeof (WAVEHDR)) != MMSYSERR_NOERROR ) {\r
+               GlobalUnlock (hg);\r
+               GlobalFree   (hg);\r
+               return -1;\r
+       }\r
+\r
+       if ( waveOutWrite ( dev, wh, sizeof (WAVEHDR)) != MMSYSERR_NOERROR ) {\r
+               GlobalUnlock (hg);\r
+               GlobalFree   (hg);\r
+               return -1;\r
+       }\r
+\r
+       EnterCriticalSection ( &cs );\r
+       ScheduledBlocks++;\r
+       LeaveCriticalSection ( &cs );\r
+\r
+       return len;\r
+}\r
+\r
+\r
+int\r
+WIN_Audio_close ( void )\r
+{\r
+       if ( dev != NULL ) {\r
+\r
+               while ( ScheduledBlocks > 0 ) {\r
+                       Sleep (ScheduledBlocks);\r
+                       while ( PlayedWaveHeadersCount > 0 )         // free used blocks ...\r
+                               free_memory ();\r
+               }\r
+\r
+               waveOutReset (dev);      // reset the device\r
+               waveOutClose (dev);      // close the device\r
+               dev = NULL;\r
+       }\r
+\r
+       DeleteCriticalSection ( &cs );\r
+       ScheduledBlocks = 0;\r
+       return 0;\r
+}\r
+\r
+#endif\r
+\r
+/* end of wave_out.c */\r
diff --git a/tools/wave_out.h b/tools/wave_out.h
new file mode 100644 (file)
index 0000000..0c467b1
--- /dev/null
@@ -0,0 +1,71 @@
+/* Copyright (c) 2002, John Edwards\r
+\r
+   Redistribution and use in source and binary forms, with or without\r
+   modification, are permitted provided that the following conditions\r
+   are met:\r
+\r
+   - Redistributions of source code must retain the above copyright\r
+   notice, this list of conditions and the following disclaimer.\r
+\r
+   - Redistributions in binary form must reproduce the above copyright\r
+   notice, this list of conditions and the following disclaimer in the\r
+   documentation and/or other materials provided with the distribution.\r
+\r
+   - Neither the name of the Xiph.org Foundation nor the names of its\r
+   contributors may be used to endorse or promote products derived from\r
+   this software without specific prior written permission.\r
+\r
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR\r
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\r
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\r
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+*/\r
+\r
+//    WAVE_OUT.H - Necessary stuff for WIN_AUDIO\r
+\r
+#ifndef WAVE_OUT_H\r
+#define WAVE_OUT_H\r
+\r
+#include <stdio.h>\r
+#include <windows.h>\r
+#ifdef __MINGW32__\r
+#include <mmsystem.h>\r
+#endif\r
+\r
+#define VERSION_STRING "\n 0.7.0\n"\r
+\r
+#define Cdecl               __cdecl\r
+#define __attribute__(x)\r
+#define sleep(__sec)        Sleep ((__sec) * 1000)\r
+#define inline              __inline\r
+#define restrict\r
+\r
+//// constants /////////////////////////////////////////////////////\r
+\r
+#define CD_SAMPLE_FREQ         44.1e3\r
+#define SAMPLE_SIZE            16\r
+#define SAMPLE_SIZE_STRING     ""\r
+#define WINAUDIO_FD            ((FILE_T)-128)\r
+#define FILE_T                 FILE*\r
+#define INVALID_FILEDESC       NULL\r
+\r
+//// Simple types //////////////////////////////////////////////////\r
+\r
+typedef signed   int        Int;        // at least -32767...+32767, fast type\r
+typedef unsigned int        Uint;       // at least 0...65535, fast type\r
+typedef long double         Ldouble;    // most exact floating point format\r
+\r
+//// procedures/functions //////////////////////////////////////////\r
+// wave_out.c\r
+Int        Set_WIN_Params             ( FILE_T dummyFile , Ldouble SampleFreq, Uint BitsPerSample, Uint Channels);\r
+int        WIN_Play_Samples           ( const void* buff, size_t len );\r
+int        WIN_Audio_close            ( void );\r
+\r
+#endif /* WAVE_OUT_H */\r