WDL/vorbisencdec.h

   1 /*
   2     WDL - vorbisencdec.h
   3     Copyright (C) 2005 and later, Cockos Incorporated
   4
   5     This software is provided 'as-is', without any express or implied
   6     warranty.  In no event will the authors be held liable for any damages
   7     arising from the use of this software.
   8
   9     Permission is granted to anyone to use this software for any purpose,
  10     including commercial applications, and to alter it and redistribute it
  11     freely, subject to the following restrictions:
  12
  13     1. The origin of this software must not be misrepresented; you must not
  14        claim that you wrote the original software. If you use this software
  15        in a product, an acknowledgment in the product documentation would be
  16        appreciated but is not required.
  17     2. Altered source versions must be plainly marked as such, and must not be
  18        misrepresented as being the original software.
  19     3. This notice may not be removed or altered from any source distribution.
  20
  21
  22 */
  23
  24 /*
  25
  26   This file provides simple interfaces for encoding and decoding of OGG Vorbis data.
  27   It is a wrapper around what their SDKs expose, which is not too easy to use.
  28
  29   This stuff is pretty limited and simple, but works, usually.
  30
  31   For full control you probably want to #define VORBISENC_WANT_FULLCONFIG
  32   but for compatibility with some older code, it's left disabled here.
  33
  34 */
  35
  36 #ifndef _VORBISENCDEC_H_
  37 #define _VORBISENCDEC_H_
  38
  39 #ifndef OV_EXCLUDE_STATIC_CALLBACKS
  40 #define OV_EXCLUDE_STATIC_CALLBACKS
  41 #endif
  42 #include "vorbis/vorbisenc.h"
  43 #include "vorbis/codec.h"
  44
  45 class VorbisDecoderInterface
  46 {
  47 public:
  48   virtual ~VorbisDecoderInterface(){}
  49   virtual int GetSampleRate()=0;
  50   virtual int GetNumChannels()=0;
  51   virtual void *DecodeGetSrcBuffer(int srclen)=0;
  52   virtual void DecodeWrote(int srclen)=0;
  53   virtual void Reset()=0;
  54   virtual int Available()=0;
  55   virtual float *Get()=0;
  56   virtual void Skip(int amt)=0;
  57 };
  58
  59 class VorbisEncoderInterface
  60 {
  61 public:
  62   virtual ~VorbisEncoderInterface(){}
  63   virtual void Encode(float *in, int inlen, int advance=1, int spacing=1)=0; // length in sample (PAIRS)
  64   virtual int isError()=0;
  65   virtual int Available()=0;
  66   virtual void *Get()=0;
  67   virtual void Advance(int)=0;
  68   virtual void Compact()=0;
  69   virtual void reinit(int bla=0)=0;
  70 };
  71
  72
  73 #ifndef WDL_VORBIS_INTERFACE_ONLY
  74
  75 #include "../WDL/queue.h"
  76
  77 class VorbisDecoder : public VorbisDecoderInterface
  78 {
  79   public:
  80     VorbisDecoder()
  81     {
  82       m_samples_used=0;
  83         packets=0;
  84             memset(&oy,0,sizeof(oy));
  85             memset(&os,0,sizeof(os));
  86             memset(&og,0,sizeof(og));
  87             memset(&op,0,sizeof(op));
  88             memset(&vi,0,sizeof(vi));
  89             memset(&vc,0,sizeof(vc));
  90             memset(&vd,0,sizeof(vd));
  91             memset(&vb,0,sizeof(vb));
  92
  93
  94       ogg_sync_init(&oy); /* Now we can read pages */
  95       m_err=0;
  96     }
  97     ~VorbisDecoder()
  98     {
  99       ogg_stream_clear(&os);
 100       vorbis_block_clear(&vb);
 101       vorbis_dsp_clear(&vd);
 102             vorbis_comment_clear(&vc);
 103       vorbis_info_clear(&vi);
 104
 105           ogg_sync_clear(&oy);
 106     }
 107
 108     int GetSampleRate() { return vi.rate; }
 109     int GetNumChannels() { return vi.channels?vi.channels:1; }
 110
 111     void *DecodeGetSrcBuffer(int srclen)
 112     {
 113                   return ogg_sync_buffer(&oy,srclen);
 114     }
 115
 116     void DecodeWrote(int srclen)
 117     {
 118       ogg_sync_wrote(&oy,srclen);
 119
 120                   while(ogg_sync_pageout(&oy,&og)>0)
 121                   {
 122                           int serial=ogg_page_serialno(&og);
 123                           if (!packets) ogg_stream_init(&os,serial);
 124                           else if (serial!=os.serialno)
 125                           {
 126                                   vorbis_block_clear(&vb);
 127                                   vorbis_dsp_clear(&vd);
 128                                   vorbis_comment_clear(&vc);
 129                                   vorbis_info_clear(&vi);
 130
 131                                   ogg_stream_clear(&os);
 132                                   ogg_stream_init(&os,serial);
 133                                   packets=0;
 134                           }
 135                           if (!packets)
 136                           {
 137                                   vorbis_info_init(&vi);
 138                                   vorbis_comment_init(&vc);
 139                           }
 140                           ogg_stream_pagein(&os,&og);
 141                           while(ogg_stream_packetout(&os,&op)>0)
 142                           {
 143                                   if (packets<3)
 144                                   {
 145                                           if(vorbis_synthesis_headerin(&vi,&vc,&op)<0) return;
 146                                   }
 147                                   else
 148                                   {
 149                                           float ** pcm;
 150                                           int samples;
 151                                           if(vorbis_synthesis(&vb,&op)==0) vorbis_synthesis_blockin(&vd,&vb);
 152                                           while((samples=vorbis_synthesis_pcmout(&vd,&pcm))>0)
 153                                           {
 154                                                   int n,c;
 155
 156               int newsize=(m_samples_used+(samples+4096)*vi.channels)*sizeof(float);
 157
 158               if (m_samples.GetSize() < newsize) m_samples.Resize(newsize+32768);
 159
 160               float *bufmem = (float *)m_samples.Get();
 161
 162                                                   for(n=0;n<samples;n++)
 163                                                   {
 164                                                           for(c=0;c<vi.channels;c++)
 165                                                           {
 166                                                                   bufmem[m_samples_used++]=pcm[c][n];
 167                                                           }
 168                                                   }
 169                                                   vorbis_synthesis_read(&vd,samples);
 170                                           }
 171                                   }
 172                                   packets++;
 173                                   if (packets==3)
 174                                   {
 175                                           vorbis_synthesis_init(&vd,&vi);
 176                                           vorbis_block_init(&vd,&vb);
 177                                   }
 178                           }
 179                   }
 180     }
 181     int Available()
 182     {
 183       return m_samples_used;
 184     }
 185     float *Get()
 186     {
 187       return (float *)m_samples.Get();
 188     }
 189     void Skip(int amt)
 190     {
 191       float *sptr=(float *)m_samples.Get();
 192       m_samples_used-=amt;
 193       if (m_samples_used>0)
 194         memcpy(sptr,sptr+amt,m_samples_used*sizeof(float));
 195       else m_samples_used=0;
 196     }
 197
 198     void Reset()
 199     {
 200       m_samples_used=0;
 201
 202                         vorbis_block_clear(&vb);
 203                         vorbis_dsp_clear(&vd);
 204                         vorbis_comment_clear(&vc);
 205                         vorbis_info_clear(&vi);
 206
 207                         ogg_stream_clear(&os);
 208                         packets=0;
 209     }
 210
 211   private:
 212
 213     WDL_HeapBuf m_samples; // we let the size get as big as it needs to, so we don't worry about tons of mallocs/etc
 214
 215     int m_err;
 216     int packets;
 217     int m_samples_used;
 218
 219     ogg_sync_state   oy; /* sync and verify incoming physical bitstream */
 220     ogg_stream_state os; /* take physical pages, weld into a logical
 221                             stream of packets */
 222     ogg_page         og; /* one Ogg bitstream page.  Vorbis packets are inside */
 223     ogg_packet       op; /* one raw packet of data for decode */
 224
 225     vorbis_info      vi; /* struct that stores all the static vorbis bitstream
 226                             settings */
 227     vorbis_comment   vc; /* struct that stores all the bitstream user comments */
 228     vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
 229     vorbis_block     vb; /* local working space for packet->PCM decode */
 230
 231
 232 } WDL_FIXALIGN;
 233
 234
 235 class VorbisEncoder : public VorbisEncoderInterface
 236 {
 237 public:
 238 #ifdef VORBISENC_WANT_FULLCONFIG
 239   VorbisEncoder(int srate, int nch, int serno, float qv, int cbr=-1, int minbr=-1, int maxbr=-1, const char *encname=NULL)
 240 #elif defined(VORBISENC_WANT_QVAL)
 241   VorbisEncoder(int srate, int nch, float qv, int serno, const char *encname=NULL)
 242 #else
 243   VorbisEncoder(int srate, int nch, int bitrate, int serno, const char *encname=NULL)
 244 #endif
 245   {
 246     m_flushmode=false;
 247     m_ds=0;
 248
 249     memset(&vi,0,sizeof(vi));
 250     memset(&vc,0,sizeof(vc));
 251     memset(&vd,0,sizeof(vd));
 252     memset(&vb,0,sizeof(vb));
 253
 254     m_nch=nch;
 255     vorbis_info_init(&vi);
 256
 257 #ifdef VORBISENC_WANT_FULLCONFIG
 258
 259     if (cbr > 0)
 260     {
 261       m_err=vorbis_encode_init(&vi,nch,srate,maxbr*1000,cbr*1000,minbr*1000);
 262     }
 263     else
 264       m_err=vorbis_encode_init_vbr(&vi,nch,srate,qv);
 265
 266 #else
 267
 268   #ifndef VORBISENC_WANT_QVAL
 269       float qv=0.0;
 270       if (nch == 2) bitrate=  (bitrate*5)/8;
 271       // at least for mono 44khz
 272       //-0.1 = ~40kbps
 273       //0.0 == ~64kbps
 274       //0.1 == 75
 275       //0.3 == 95
 276       //0.5 == 110
 277       //0.75== 140
 278       //1.0 == 240
 279       if (bitrate <= 32)
 280       {
 281         m_ds=1;
 282         bitrate*=2;
 283       }
 284
 285       if (bitrate < 40) qv=-0.1f;
 286       else if (bitrate < 64) qv=-0.10f + (bitrate-40)*(0.10f/24.0f);
 287       else if (bitrate < 75) qv=(bitrate-64)*(0.1f/9.0f);
 288       else if (bitrate < 95) qv=0.1f+(bitrate-75)*(0.2f/20.0f);
 289       else if (bitrate < 110) qv=0.3f+(bitrate-95)*(0.2f/15.0f);
 290       else if (bitrate < 140) qv=0.5f+(bitrate-110)*(0.25f/30.0f);
 291       else qv=0.75f+(bitrate-140)*(0.25f/100.0f);
 292
 293       if (qv<-0.10f)qv=-0.10f;
 294       if (qv>1.0f)qv=1.0f;
 295   #endif
 296
 297       m_err=vorbis_encode_init_vbr(&vi,nch,srate>>m_ds,qv);
 298 #endif
 299
 300     vorbis_comment_init(&vc);
 301     if (encname) vorbis_comment_add_tag(&vc,"ENCODER",(char *)encname);
 302     vorbis_analysis_init(&vd,&vi);
 303     vorbis_block_init(&vd,&vb);
 304     ogg_stream_init(&os,m_ser=serno);
 305
 306     if (m_err) return;
 307
 308
 309     reinit(1);
 310   }
 311
 312   void reinit(int bla=0)
 313   {
 314     if (!bla)
 315     {
 316       ogg_stream_clear(&os);
 317       vorbis_block_clear(&vb);
 318       vorbis_dsp_clear(&vd);
 319
 320       vorbis_analysis_init(&vd,&vi);
 321       vorbis_block_init(&vd,&vb);
 322       ogg_stream_init(&os,m_ser++); //++?
 323
 324       outqueue.Advance(outqueue.Available());
 325       outqueue.Compact();
 326     }
 327
 328
 329     ogg_packet header;
 330     ogg_packet header_comm;
 331     ogg_packet header_code;
 332     vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
 333     ogg_stream_packetin(&os,&header); /* automatically placed in its own page */
 334     ogg_stream_packetin(&os,&header_comm);
 335     ogg_stream_packetin(&os,&header_code);
 336
 337           for (;;)
 338     {
 339       ogg_page og;
 340                   int result=ogg_stream_flush(&os,&og);
 341                   if(result==0)break;
 342       outqueue.Add(og.header,og.header_len);
 343                   outqueue.Add(og.body,og.body_len);
 344           }
 345   }
 346
 347   void Encode(float *in, int inlen, int advance=1, int spacing=1) // length in sample (PAIRS)
 348   {
 349     if (m_err) return;
 350
 351     if (inlen == 0)
 352     {
 353       // disable this for now, it fucks us sometimes
 354       // maybe we should throw some silence in instead?
 355         vorbis_analysis_wrote(&vd,0);
 356     }
 357     else
 358     {
 359       inlen >>= m_ds;
 360       float **buffer=vorbis_analysis_buffer(&vd,inlen);
 361       int i,i2=0;
 362
 363       if (m_nch==1)
 364       {
 365         for (i = 0; i < inlen; i ++)
 366         {
 367           buffer[0][i]=in[i2];
 368           i2+=advance<<m_ds;
 369         }
 370       }
 371       else if (m_nch==2)
 372       {
 373         for (i = 0; i < inlen; i ++)
 374         {
 375           buffer[0][i]=in[i2];
 376           buffer[1][i]=in[i2+spacing];
 377           i2+=advance<<m_ds;
 378         }
 379       }
 380       else if (m_nch>2)
 381       {
 382         int n=m_nch;
 383         for (i = 0; i < inlen; i ++)
 384         {
 385           int a;
 386           int i3=i2;
 387           for(a=0;a<n;a++,i3+=spacing)
 388             buffer[a][i]=in[i3];
 389           i2+=advance<<m_ds;
 390         }
 391       }
 392       vorbis_analysis_wrote(&vd,i);
 393     }
 394
 395     int eos=0;
 396     while(vorbis_analysis_blockout(&vd,&vb)==1)
 397     {
 398       vorbis_analysis(&vb,NULL);
 399       vorbis_bitrate_addblock(&vb);
 400       ogg_packet       op;
 401
 402       while(vorbis_bitrate_flushpacket(&vd,&op))
 403       {
 404
 405         ogg_stream_packetin(&os,&op);
 406
 407               while (!eos)
 408         {
 409           ogg_page og;
 410           int result=m_flushmode ? ogg_stream_flush(&os,&og) : ogg_stream_pageout(&os,&og);
 411                       if(result==0)break;
 412           outqueue.Add(og.header,og.header_len);
 413                       outqueue.Add(og.body,og.body_len);
 414           if(ogg_page_eos(&og)) eos=1;
 415               }
 416       }
 417     }
 418   }
 419
 420   int isError() { return m_err; }
 421
 422   int Available()
 423   {
 424     return outqueue.Available();
 425   }
 426   void *Get()
 427   {
 428     return outqueue.Get();
 429   }
 430   void Advance(int amt)
 431   {
 432     outqueue.Advance(amt);
 433   }
 434
 435   void Compact()
 436   {
 437     outqueue.Compact();
 438   }
 439
 440   ~VorbisEncoder()
 441   {
 442     ogg_stream_clear(&os);
 443     vorbis_block_clear(&vb);
 444     vorbis_dsp_clear(&vd);
 445     vorbis_comment_clear(&vc);
 446     if (!m_err) vorbis_info_clear(&vi);
 447   }
 448
 449   WDL_Queue outqueue;
 450
 451 private:
 452   int m_err,m_nch;
 453
 454   ogg_stream_state os;
 455   vorbis_info      vi;
 456   vorbis_comment   vc;
 457   vorbis_dsp_state vd;
 458   vorbis_block     vb;
 459   int m_ser;
 460   int m_ds;
 461
 462 public:
 463   bool m_flushmode;
 464 } WDL_FIXALIGN;
 465
 466 #endif//WDL_VORBIS_INTERFACE_ONLY
 467
 468 #endif//_VORBISENCDEC_H_