apps/codecs/libspeex/oggframing.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   7  *                                                                  *
   8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
   9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13  function: code raw [Vorbis] packets into framed OggSquish stream and
  14            decode Ogg streams back into raw packets
  15  last mod: $Id$
  16
  17  note: The CRC code is directly derived from public domain code by
  18  Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html
  19  for details.
  20
  21  ********************************************************************/
  22
  23 //#include "config-tremor.h"
  24 #include <string.h>
  25 #include "speex/ogg.h"
  26 #include "arch.h"
  27
  28 /* A complete description of Ogg framing exists in docs/framing.html */
  29
  30 int spx_ogg_page_version(spx_ogg_page *og){
  31   return((int)(og->header[4]));
  32 }
  33
  34 int spx_ogg_page_continued(spx_ogg_page *og){
  35   return((int)(og->header[5]&0x01));
  36 }
  37
  38 int spx_ogg_page_bos(spx_ogg_page *og){
  39   return((int)(og->header[5]&0x02));
  40 }
  41
  42 int spx_ogg_page_eos(spx_ogg_page *og){
  43   return((int)(og->header[5]&0x04));
  44 }
  45
  46 spx_ogg_int64_t spx_ogg_page_granulepos(spx_ogg_page *og){
  47   unsigned char *page=og->header;
  48   spx_ogg_int64_t granulepos=page[13]&(0xff);
  49   granulepos= (granulepos<<8)|(page[12]&0xff);
  50   granulepos= (granulepos<<8)|(page[11]&0xff);
  51   granulepos= (granulepos<<8)|(page[10]&0xff);
  52   granulepos= (granulepos<<8)|(page[9]&0xff);
  53   granulepos= (granulepos<<8)|(page[8]&0xff);
  54   granulepos= (granulepos<<8)|(page[7]&0xff);
  55   granulepos= (granulepos<<8)|(page[6]&0xff);
  56   return(granulepos);
  57 }
  58
  59 int spx_ogg_page_serialno(spx_ogg_page *og){
  60   return(og->header[14] |
  61          (og->header[15]<<8) |
  62          (og->header[16]<<16) |
  63          (og->header[17]<<24));
  64 }
  65
  66 long spx_ogg_page_pageno(spx_ogg_page *og){
  67   return(og->header[18] |
  68          (og->header[19]<<8) |
  69          (og->header[20]<<16) |
  70          (og->header[21]<<24));
  71 }
  72
  73
  74
  75 /* returns the number of packets that are completed on this page (if
  76    the leading packet is begun on a previous page, but ends on this
  77    page, it's counted */
  78
  79 /* NOTE:
  80 If a page consists of a packet begun on a previous page, and a new
  81 packet begun (but not completed) on this page, the return will be:
  82   spx_ogg_page_packets(page)   ==1,
  83   spx_ogg_page_continued(page) !=0
  84
  85 If a page happens to be a single packet that was begun on a
  86 previous page, and spans to the next page (in the case of a three or
  87 more page packet), the return will be:
  88   spx_ogg_page_packets(page)   ==0,
  89   spx_ogg_page_continued(page) !=0
  90 */
  91
  92 int spx_ogg_page_packets(spx_ogg_page *og){
  93   int i,n=og->header[26],count=0;
  94   for(i=0;i<n;i++)
  95     if(og->header[27+i]<255)count++;
  96   return(count);
  97 }
  98
  99
 100 #if 0
 101 /* helper to initialize lookup for direct-table CRC (illustrative; we
 102    use the static init below) */
 103
 104 static spx_ogg_uint32_t _spx_ogg_crc_entry(unsigned long index){
 105   int           i;
 106   unsigned long r;
 107
 108   r = index << 24;
 109   for (i=0; i<8; i++)
 110     if (r & 0x80000000UL)
 111       r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
 112                                     polynomial, although we use an
 113                                     unreflected alg and an init/final
 114                                     of 0, not 0xffffffff */
 115     else
 116        r<<=1;
 117  return (r & 0xffffffffUL);
 118 }
 119 #endif
 120
 121 static const spx_ogg_uint32_t crc_lookup[256]={
 122   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
 123   0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
 124   0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
 125   0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
 126   0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
 127   0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
 128   0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
 129   0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
 130   0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
 131   0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
 132   0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
 133   0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
 134   0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
 135   0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
 136   0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
 137   0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
 138   0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
 139   0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
 140   0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
 141   0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
 142   0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
 143   0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
 144   0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
 145   0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
 146   0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
 147   0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
 148   0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
 149   0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
 150   0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
 151   0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
 152   0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
 153   0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
 154   0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
 155   0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
 156   0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
 157   0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
 158   0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
 159   0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
 160   0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
 161   0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
 162   0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
 163   0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
 164   0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
 165   0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
 166   0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
 167   0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
 168   0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
 169   0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
 170   0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
 171   0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
 172   0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
 173   0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
 174   0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
 175   0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
 176   0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
 177   0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
 178   0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
 179   0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
 180   0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
 181   0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
 182   0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
 183   0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
 184   0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
 185   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
 186
 187 /* init the encode/decode logical stream state */
 188
 189 int spx_ogg_stream_init(spx_ogg_stream_state *os,int serialno){
 190   if(os){
 191     memset(os,0,sizeof(*os));
 192     os->body_storage=16*1024;
 193     os->body_data=_spx_ogg_malloc(os->body_storage*sizeof(*os->body_data));
 194
 195     os->lacing_storage=1024;
 196     os->lacing_vals=_spx_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
 197     os->granule_vals=_spx_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
 198
 199     os->serialno=serialno;
 200
 201     return(0);
 202   }
 203   return(-1);
 204 }
 205
 206 /* _clear does not free os, only the non-flat storage within */
 207 int spx_ogg_stream_clear(spx_ogg_stream_state *os){
 208   if(os){
 209     if(os->body_data)_spx_ogg_free(os->body_data);
 210     if(os->lacing_vals)_spx_ogg_free(os->lacing_vals);
 211     if(os->granule_vals)_spx_ogg_free(os->granule_vals);
 212
 213     memset(os,0,sizeof(*os));
 214   }
 215   return(0);
 216 }
 217
 218 int spx_ogg_stream_destroy(spx_ogg_stream_state *os){
 219   if(os){
 220     spx_ogg_stream_clear(os);
 221     _spx_ogg_free(os);
 222   }
 223   return(0);
 224 }
 225
 226 /* Helpers for spx_ogg_stream_encode; this keeps the structure and
 227    what's happening fairly clear */
 228
 229 static void _os_body_expand(spx_ogg_stream_state *os,int needed){
 230   if(os->body_storage<=os->body_fill+needed){
 231     os->body_storage+=(needed+1024);
 232     os->body_data=_spx_ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));
 233   }
 234 }
 235
 236 static void _os_lacing_expand(spx_ogg_stream_state *os,int needed){
 237   if(os->lacing_storage<=os->lacing_fill+needed){
 238     os->lacing_storage+=(needed+32);
 239     os->lacing_vals=_spx_ogg_realloc(os->lacing_vals,os->lacing_storage*sizeof(*os->lacing_vals));
 240     os->granule_vals=_spx_ogg_realloc(os->granule_vals,os->lacing_storage*sizeof(*os->granule_vals));
 241   }
 242 }
 243
 244 /* checksum the page */
 245 /* Direct table CRC; note that this will be faster in the future if we
 246    perform the checksum silmultaneously with other copies */
 247
 248 void spx_ogg_page_checksum_set(spx_ogg_page *og){
 249   if(og){
 250     spx_ogg_uint32_t crc_reg=0;
 251     int i;
 252
 253     /* safety; needed for API behavior, but not framing code */
 254     og->header[22]=0;
 255     og->header[23]=0;
 256     og->header[24]=0;
 257     og->header[25]=0;
 258
 259     for(i=0;i<og->header_len;i++)
 260       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
 261     for(i=0;i<og->body_len;i++)
 262       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
 263
 264     og->header[22]=(unsigned char)(crc_reg&0xff);
 265     og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
 266     og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
 267     og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
 268   }
 269 }
 270
 271 /* submit data to the internal buffer of the framing engine */
 272 int spx_ogg_stream_packetin(spx_ogg_stream_state *os,spx_ogg_packet *op){
 273   int lacing_vals=op->bytes/255+1,i;
 274
 275   if(os->body_returned){
 276     /* advance packet data according to the body_returned pointer. We
 277        had to keep it around to return a pointer into the buffer last
 278        call */
 279
 280     os->body_fill-=os->body_returned;
 281     if(os->body_fill)
 282       memmove(os->body_data,os->body_data+os->body_returned,
 283               os->body_fill);
 284     os->body_returned=0;
 285   }
 286
 287   /* make sure we have the buffer storage */
 288   _os_body_expand(os,op->bytes);
 289   _os_lacing_expand(os,lacing_vals);
 290
 291   /* Copy in the submitted packet.  Yes, the copy is a waste; this is
 292      the liability of overly clean abstraction for the time being.  It
 293      will actually be fairly easy to eliminate the extra copy in the
 294      future */
 295
 296   memcpy(os->body_data+os->body_fill,op->packet,op->bytes);
 297   os->body_fill+=op->bytes;
 298
 299   /* Store lacing vals for this packet */
 300   for(i=0;i<lacing_vals-1;i++){
 301     os->lacing_vals[os->lacing_fill+i]=255;
 302     os->granule_vals[os->lacing_fill+i]=os->granulepos;
 303   }
 304   os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;
 305   os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;
 306
 307   /* flag the first segment as the beginning of the packet */
 308   os->lacing_vals[os->lacing_fill]|= 0x100;
 309
 310   os->lacing_fill+=lacing_vals;
 311
 312   /* for the sake of completeness */
 313   os->packetno++;
 314
 315   if(op->e_o_s)os->e_o_s=1;
 316
 317   return(0);
 318 }
 319
 320 /* This will flush remaining packets into a page (returning nonzero),
 321    even if there is not enough data to trigger a flush normally
 322    (undersized page). If there are no packets or partial packets to
 323    flush, spx_ogg_stream_flush returns 0.  Note that spx_ogg_stream_flush will
 324    try to flush a normal sized page like spx_ogg_stream_pageout; a call to
 325    spx_ogg_stream_flush does not guarantee that all packets have flushed.
 326    Only a return value of 0 from spx_ogg_stream_flush indicates all packet
 327    data is flushed into pages.
 328
 329    since spx_ogg_stream_flush will flush the last page in a stream even if
 330    it's undersized, you almost certainly want to use spx_ogg_stream_pageout
 331    (and *not* spx_ogg_stream_flush) unless you specifically need to flush
 332    an page regardless of size in the middle of a stream. */
 333
 334 int spx_ogg_stream_flush(spx_ogg_stream_state *os,spx_ogg_page *og){
 335   int i;
 336   int vals=0;
 337   int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
 338   int bytes=0;
 339   long acc=0;
 340   spx_ogg_int64_t granule_pos=-1;
 341
 342   if(maxvals==0)return(0);
 343
 344   /* construct a page */
 345   /* decide how many segments to include */
 346
 347   /* If this is the initial header case, the first page must only include
 348      the initial header packet */
 349   if(os->b_o_s==0){  /* 'initial header page' case */
 350     granule_pos=0;
 351     for(vals=0;vals<maxvals;vals++){
 352       if((os->lacing_vals[vals]&0x0ff)<255){
 353         vals++;
 354         break;
 355       }
 356     }
 357   }else{
 358     for(vals=0;vals<maxvals;vals++){
 359       if(acc>4096)break;
 360       acc+=os->lacing_vals[vals]&0x0ff;
 361       if((os->lacing_vals[vals]&0xff)<255)
 362         granule_pos=os->granule_vals[vals];
 363     }
 364   }
 365
 366   /* construct the header in temp storage */
 367   memcpy(os->header,"OggS",4);
 368
 369   /* stream structure version */
 370   os->header[4]=0x00;
 371
 372   /* continued packet flag? */
 373   os->header[5]=0x00;
 374   if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;
 375   /* first page flag? */
 376   if(os->b_o_s==0)os->header[5]|=0x02;
 377   /* last page flag? */
 378   if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;
 379   os->b_o_s=1;
 380
 381   /* 64 bits of PCM position */
 382   for(i=6;i<14;i++){
 383     os->header[i]=(unsigned char)(granule_pos&0xff);
 384     granule_pos>>=8;
 385   }
 386
 387   /* 32 bits of stream serial number */
 388   {
 389     long serialno=os->serialno;
 390     for(i=14;i<18;i++){
 391       os->header[i]=(unsigned char)(serialno&0xff);
 392       serialno>>=8;
 393     }
 394   }
 395
 396   /* 32 bits of page counter (we have both counter and page header
 397      because this val can roll over) */
 398   if(os->pageno==-1)os->pageno=0; /* because someone called
 399                                      stream_reset; this would be a
 400                                      strange thing to do in an
 401                                      encode stream, but it has
 402                                      plausible uses */
 403   {
 404     long pageno=os->pageno++;
 405     for(i=18;i<22;i++){
 406       os->header[i]=(unsigned char)(pageno&0xff);
 407       pageno>>=8;
 408     }
 409   }
 410
 411   /* zero for computation; filled in later */
 412   os->header[22]=0;
 413   os->header[23]=0;
 414   os->header[24]=0;
 415   os->header[25]=0;
 416
 417   /* segment table */
 418   os->header[26]=(unsigned char)(vals&0xff);
 419   for(i=0;i<vals;i++)
 420     bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);
 421
 422   /* set pointers in the spx_ogg_page struct */
 423   og->header=os->header;
 424   og->header_len=os->header_fill=vals+27;
 425   og->body=os->body_data+os->body_returned;
 426   og->body_len=bytes;
 427
 428   /* advance the lacing data and set the body_returned pointer */
 429
 430   os->lacing_fill-=vals;
 431   memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));
 432   memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));
 433   os->body_returned+=bytes;
 434
 435   /* calculate the checksum */
 436
 437   spx_ogg_page_checksum_set(og);
 438
 439   /* done */
 440   return(1);
 441 }
 442
 443
 444 /* This constructs pages from buffered packet segments.  The pointers
 445 returned are to static buffers; do not free. The returned buffers are
 446 good only until the next call (using the same spx_ogg_stream_state) */
 447
 448 int spx_ogg_stream_pageout(spx_ogg_stream_state *os, spx_ogg_page *og){
 449
 450   if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
 451      os->body_fill-os->body_returned > 4096 ||/* 'page nominal size' case */
 452      os->lacing_fill>=255 ||                  /* 'segment table full' case */
 453      (os->lacing_fill&&!os->b_o_s)){          /* 'initial header page' case */
 454
 455     return(spx_ogg_stream_flush(os,og));
 456   }
 457
 458   /* not enough data to construct a page and not end of stream */
 459   return(0);
 460 }
 461
 462 int spx_ogg_stream_eos(spx_ogg_stream_state *os){
 463   return os->e_o_s;
 464 }
 465
 466 /* DECODING PRIMITIVES: packet streaming layer **********************/
 467
 468 /* This has two layers to place more of the multi-serialno and paging
 469    control in the application's hands.  First, we expose a data buffer
 470    using spx_ogg_sync_buffer().  The app either copies into the
 471    buffer, or passes it directly to read(), etc.  We then call
 472    spx_ogg_sync_wrote() to tell how many bytes we just added.
 473
 474    Pages are returned (pointers into the buffer in spx_ogg_sync_state)
 475    by spx_ogg_sync_pageout().  The page is then submitted to
 476    spx_ogg_stream_pagein() along with the appropriate
 477    spx_ogg_stream_state* (ie, matching serialno).  We then get raw
 478    packets out calling spx_ogg_stream_packetout() with a
 479    spx_ogg_stream_state. */
 480
 481 /* initialize the struct to a known state */
 482 int spx_ogg_sync_init(spx_ogg_sync_state *oy){
 483   if(oy){
 484     memset(oy,0,sizeof(*oy));
 485   }
 486   return(0);
 487 }
 488
 489 /* clear non-flat storage within */
 490 int spx_ogg_sync_clear(spx_ogg_sync_state *oy){
 491   if(oy){
 492     if(oy->data)_spx_ogg_free(oy->data);
 493     spx_ogg_sync_init(oy);
 494   }
 495   return(0);
 496 }
 497
 498 int spx_ogg_sync_destroy(spx_ogg_sync_state *oy){
 499   if(oy){
 500     spx_ogg_sync_clear(oy);
 501     _spx_ogg_free(oy);
 502   }
 503   return(0);
 504 }
 505 void spx_ogg_alloc_buffer(spx_ogg_sync_state *oy, long size){
 506     long newsize=size+oy->fill+size; /* an extra page to be nice */
 507     if(oy->data){
 508       oy->data=_spx_ogg_realloc(oy->data,newsize);
 509     }else
 510       oy->data=_spx_ogg_malloc(newsize);
 511     oy->storage=newsize;
 512     return;
 513 }
 514
 515 char *spx_ogg_sync_buffer(spx_ogg_sync_state *oy, long size){
 516
 517   /* first, clear out any space that has been previously returned */
 518   if(oy->returned){
 519     oy->fill-=oy->returned;
 520     if(oy->fill>0)
 521       memmove(oy->data,oy->data+oy->returned,oy->fill);
 522     oy->returned=0;
 523   }
 524
 525   if(size>oy->storage-oy->fill){
 526     /* We need to extend the internal buffer */
 527     long newsize=size+oy->fill+4096; /* an extra page to be nice */
 528     if(oy->data){
 529       oy->data=_spx_ogg_realloc(oy->data,newsize);
 530     }else
 531       oy->data=_spx_ogg_malloc(newsize);
 532     oy->storage=newsize;
 533   }
 534
 535   /* expose a segment at least as large as requested at the fill mark */
 536   return((char *)oy->data+oy->fill);
 537 }
 538
 539 int spx_ogg_sync_wrote(spx_ogg_sync_state *oy, long bytes){
 540   if(oy->fill+bytes>oy->storage)return(-1);
 541   oy->fill+=bytes;
 542   return(0);
 543 }
 544
 545 /* sync the stream.  This is meant to be useful for finding page
 546    boundaries.
 547
 548    return values for this:
 549   -n) skipped n bytes
 550    0) page not ready; more data (no bytes skipped)
 551    n) page synced at current location; page length n bytes
 552
 553 */
 554
 555 long spx_ogg_sync_pageseek(spx_ogg_sync_state *oy,spx_ogg_page *og){
 556   unsigned char *page=oy->data+oy->returned;
 557   unsigned char *next;
 558   long bytes=oy->fill-oy->returned;
 559
 560   if(oy->headerbytes==0){
 561     int headerbytes,i;
 562     if(bytes<27)return(0); /* not enough for a header */
 563
 564     /* verify capture pattern */
 565     if(memcmp(page,"OggS",4))goto sync_fail;
 566
 567     headerbytes=page[26]+27;
 568     if(bytes<headerbytes)return(0); /* not enough for header + seg table */
 569
 570     /* count up body length in the segment table */
 571
 572     for(i=0;i<page[26];i++)
 573       oy->bodybytes+=page[27+i];
 574     oy->headerbytes=headerbytes;
 575   }
 576
 577   if(oy->bodybytes+oy->headerbytes>bytes)return(0);
 578
 579   /* The whole test page is buffered.  Verify the checksum */
 580   {
 581     /* Grab the checksum bytes, set the header field to zero */
 582     char chksum[4];
 583     spx_ogg_page log;
 584
 585     memcpy(chksum,page+22,4);
 586     memset(page+22,0,4);
 587
 588     /* set up a temp page struct and recompute the checksum */
 589     log.header=page;
 590     log.header_len=oy->headerbytes;
 591     log.body=page+oy->headerbytes;
 592     log.body_len=oy->bodybytes;
 593     spx_ogg_page_checksum_set(&log);
 594
 595     /* Compare */
 596     if(memcmp(chksum,page+22,4)){
 597       /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page
 598          at all) */
 599       /* replace the computed checksum with the one actually read in */
 600       memcpy(page+22,chksum,4);
 601
 602       /* Bad checksum. Lose sync */
 603       goto sync_fail;
 604     }
 605   }
 606
 607   /* yes, have a whole page all ready to go */
 608   {
 609     unsigned char *page=oy->data+oy->returned;
 610     long bytes;
 611
 612     if(og){
 613       og->header=page;
 614       og->header_len=oy->headerbytes;
 615       og->body=page+oy->headerbytes;
 616       og->body_len=oy->bodybytes;
 617     }
 618
 619     oy->unsynced=0;
 620     oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
 621     oy->headerbytes=0;
 622     oy->bodybytes=0;
 623     return(bytes);
 624   }
 625
 626  sync_fail:
 627
 628   oy->headerbytes=0;
 629   oy->bodybytes=0;
 630
 631   /* search for possible capture */
 632   next=memchr(page+1,'O',bytes-1);
 633   if(!next)
 634     next=oy->data+oy->fill;
 635
 636   oy->returned=next-oy->data;
 637   return(-(next-page));
 638 }
 639
 640 /* sync the stream and get a page.  Keep trying until we find a page.
 641    Supress 'sync errors' after reporting the first.
 642
 643    return values:
 644    -1) recapture (hole in data)
 645     0) need more data
 646     1) page returned
 647
 648    Returns pointers into buffered data; invalidated by next call to
 649    _stream, _clear, _init, or _buffer */
 650
 651 int spx_ogg_sync_pageout(spx_ogg_sync_state *oy, spx_ogg_page *og){
 652
 653   /* all we need to do is verify a page at the head of the stream
 654      buffer.  If it doesn't verify, we look for the next potential
 655      frame */
 656
 657   for(;;){
 658     long ret=spx_ogg_sync_pageseek(oy,og);
 659     if(ret>0){
 660       /* have a page */
 661       return(1);
 662     }
 663     if(ret==0){
 664       /* need more data */
 665       return(0);
 666     }
 667
 668     /* head did not start a synced page... skipped some bytes */
 669     if(!oy->unsynced){
 670       oy->unsynced=1;
 671       return(-1);
 672     }
 673
 674     /* loop. keep looking */
 675
 676   }
 677 }
 678
 679 /* add the incoming page to the stream state; we decompose the page
 680    into packet segments here as well. */
 681
 682 int spx_ogg_stream_pagein(spx_ogg_stream_state *os, spx_ogg_page *og){
 683   unsigned char *header=og->header;
 684   unsigned char *body=og->body;
 685   long           bodysize=og->body_len;
 686   int            segptr=0;
 687
 688   int version=spx_ogg_page_version(og);
 689   int continued=spx_ogg_page_continued(og);
 690   int bos=spx_ogg_page_bos(og);
 691   int eos=spx_ogg_page_eos(og);
 692   spx_ogg_int64_t granulepos=spx_ogg_page_granulepos(og);
 693   int serialno=spx_ogg_page_serialno(og);
 694   long pageno=spx_ogg_page_pageno(og);
 695   int segments=header[26];
 696
 697   /* clean up 'returned data' */
 698   {
 699     long lr=os->lacing_returned;
 700     long br=os->body_returned;
 701
 702     /* body data */
 703     if(br){
 704       os->body_fill-=br;
 705       if(os->body_fill)
 706         memmove(os->body_data,os->body_data+br,os->body_fill);
 707       os->body_returned=0;
 708     }
 709
 710     if(lr){
 711       /* segment table */
 712       if(os->lacing_fill-lr){
 713         memmove(os->lacing_vals,os->lacing_vals+lr,
 714                 (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
 715         memmove(os->granule_vals,os->granule_vals+lr,
 716                 (os->lacing_fill-lr)*sizeof(*os->granule_vals));
 717       }
 718       os->lacing_fill-=lr;
 719       os->lacing_packet-=lr;
 720       os->lacing_returned=0;
 721     }
 722   }
 723
 724   /* check the serial number */
 725   if(serialno!=os->serialno)return(-1);
 726   if(version>0)return(-1);
 727
 728   _os_lacing_expand(os,segments+1);
 729
 730   /* are we in sequence? */
 731   if(pageno!=os->pageno){
 732     int i;
 733
 734     /* unroll previous partial packet (if any) */
 735     for(i=os->lacing_packet;i<os->lacing_fill;i++)
 736       os->body_fill-=os->lacing_vals[i]&0xff;
 737     os->lacing_fill=os->lacing_packet;
 738
 739     /* make a note of dropped data in segment table */
 740     if(os->pageno!=-1){
 741       os->lacing_vals[os->lacing_fill++]=0x400;
 742       os->lacing_packet++;
 743     }
 744   }
 745
 746   /* are we a 'continued packet' page?  If so, we may need to skip
 747      some segments */
 748   if(continued){
 749     if(os->lacing_fill<1 ||
 750        os->lacing_vals[os->lacing_fill-1]==0x400){
 751       bos=0;
 752       for(;segptr<segments;segptr++){
 753         int val=header[27+segptr];
 754         body+=val;
 755         bodysize-=val;
 756         if(val<255){
 757           segptr++;
 758           break;
 759         }
 760       }
 761     }
 762   }
 763
 764   if(bodysize){
 765     _os_body_expand(os,bodysize);
 766     memcpy(os->body_data+os->body_fill,body,bodysize);
 767     os->body_fill+=bodysize;
 768   }
 769
 770   {
 771     int saved=-1;
 772     while(segptr<segments){
 773       int val=header[27+segptr];
 774       os->lacing_vals[os->lacing_fill]=val;
 775       os->granule_vals[os->lacing_fill]=-1;
 776
 777       if(bos){
 778         os->lacing_vals[os->lacing_fill]|=0x100;
 779         bos=0;
 780       }
 781
 782       if(val<255)saved=os->lacing_fill;
 783
 784       os->lacing_fill++;
 785       segptr++;
 786
 787       if(val<255)os->lacing_packet=os->lacing_fill;
 788     }
 789
 790     /* set the granulepos on the last granuleval of the last full packet */
 791     if(saved!=-1){
 792       os->granule_vals[saved]=granulepos;
 793     }
 794
 795   }
 796
 797   if(eos){
 798     os->e_o_s=1;
 799     if(os->lacing_fill>0)
 800       os->lacing_vals[os->lacing_fill-1]|=0x200;
 801   }
 802
 803   os->pageno=pageno+1;
 804
 805   return(0);
 806 }
 807
 808 /* clear things to an initial state.  Good to call, eg, before seeking */
 809 int spx_ogg_sync_reset(spx_ogg_sync_state *oy){
 810   oy->fill=0;
 811   oy->returned=0;
 812   oy->unsynced=0;
 813   oy->headerbytes=0;
 814   oy->bodybytes=0;
 815   return(0);
 816 }
 817
 818 int spx_ogg_stream_reset(spx_ogg_stream_state *os){
 819   os->body_fill=0;
 820   os->body_returned=0;
 821
 822   os->lacing_fill=0;
 823   os->lacing_packet=0;
 824   os->lacing_returned=0;
 825
 826   os->header_fill=0;
 827
 828   os->e_o_s=0;
 829   os->b_o_s=0;
 830   os->pageno=-1;
 831   os->packetno=0;
 832   os->granulepos=0;
 833
 834   return(0);
 835 }
 836
 837 int spx_ogg_stream_reset_serialno(spx_ogg_stream_state *os,int serialno){
 838   spx_ogg_stream_reset(os);
 839   os->serialno=serialno;
 840   return(0);
 841 }
 842
 843 static int _packetout(spx_ogg_stream_state *os,spx_ogg_packet *op,int adv){
 844
 845   /* The last part of decode. We have the stream broken into packet
 846      segments.  Now we need to group them into packets (or return the
 847      out of sync markers) */
 848
 849   int ptr=os->lacing_returned;
 850
 851   if(os->lacing_packet<=ptr)return(0);
 852
 853   if(os->lacing_vals[ptr]&0x400){
 854     /* we need to tell the codec there's a gap; it might need to
 855        handle previous packet dependencies. */
 856     os->lacing_returned++;
 857     os->packetno++;
 858     return(-1);
 859   }
 860
 861   if(!op && !adv)return(1); /* just using peek as an inexpensive way
 862                                to ask if there's a whole packet
 863                                waiting */
 864
 865   /* Gather the whole packet. We'll have no holes or a partial packet */
 866   {
 867     int size=os->lacing_vals[ptr]&0xff;
 868     int bytes=size;
 869     int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */
 870     int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */
 871
 872     while(size==255){
 873       int val=os->lacing_vals[++ptr];
 874       size=val&0xff;
 875       if(val&0x200)eos=0x200;
 876       bytes+=size;
 877     }
 878
 879     if(op){
 880       op->e_o_s=eos;
 881       op->b_o_s=bos;
 882       op->packet=os->body_data+os->body_returned;
 883       op->packetno=os->packetno;
 884       op->granulepos=os->granule_vals[ptr];
 885       op->bytes=bytes;
 886     }
 887
 888     if(adv){
 889       os->body_returned+=bytes;
 890       os->lacing_returned=ptr+1;
 891       os->packetno++;
 892     }
 893   }
 894   return(1);
 895 }
 896
 897 int spx_ogg_stream_packetout(spx_ogg_stream_state *os,spx_ogg_packet *op){
 898   return _packetout(os,op,1);
 899 }
 900
 901 int spx_ogg_stream_packetpeek(spx_ogg_stream_state *os,spx_ogg_packet *op){
 902   return _packetout(os,op,0);
 903 }
 904
 905 void spx_ogg_packet_clear(spx_ogg_packet *op) {
 906   _spx_ogg_free(op->packet);
 907   memset(op, 0, sizeof(*op));
 908 }
 909