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