Ticket #4209: libogg-1.1.4.diff

File libogg-1.1.4.diff, 81.2 KB (added by herdemir, 15 years ago)

Libogg 1.1.4 patch

  • src/add-ons/media/plugins/ogg/OggTobiasStream.h

     
    77
    88class OggTobiasStream : public OggStream {
    99public:
    10     static bool IsValidHeader(const ogg_packet & packet);
     10    static bool         IsValidHeader(const ogg_packet & packet);
    1111public:
    12                 OggTobiasStream(long serialno);
    13     virtual     ~OggTobiasStream();
     12                        OggTobiasStream(long serialno);
     13    virtual             ~OggTobiasStream();
    1414
    1515    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1616                                      media_format *format);

  • src/add-ons/media/plugins/ogg/OggVorbisSeekable.h

     
    99private:
    1010    typedef OggSeekable inherited;
    1111public:
    12     static bool IsValidHeader(const ogg_packet & packet);
     12    static bool         IsValidHeader(const ogg_packet & packet);
    1313public:
    14                 OggVorbisSeekable(long serialno);
    15     virtual     ~OggVorbisSeekable();
     14                        OggVorbisSeekable(long serialno);
     15    virtual             ~OggVorbisSeekable();
    1616
    1717    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1818                                      media_format *format);

  • src/add-ons/media/plugins/ogg/OggSpeexStream.h

     
    77
    88class OggSpeexStream : public OggStream {
    99public:
    10     static bool IsValidHeader(const ogg_packet & packet);
     10    static bool         IsValidHeader(const ogg_packet & packet);
    1111public:
    12                 OggSpeexStream(long serialno);
    13     virtual     ~OggSpeexStream();
     12                        OggSpeexStream(long serialno);
     13    virtual             ~OggSpeexStream();
    1414
    1515    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1616                                      media_format *format);

  • src/add-ons/media/plugins/ogg/OggTrack.h

     
    1212protected:
    1313    static bool         findIdentifier(const ogg_packet & packet,
    1414                                       const char * id, uint pos);
    15                 OggTrack(long serialno);
     15                        OggTrack(long serialno);
    1616public:
    17     virtual     ~OggTrack();
    18     long        GetSerial() const;
     17    virtual             ~OggTrack();
     18    long                GetSerial() const;
    1919
    2020    // push interface
    2121    virtual status_t    AddPage(off_t position, const ogg_page & page) = 0;
    … …  
    2929
    3030protected:
    3131    // GetStreamInfo helpers
    32     void        SaveHeaderPacket(ogg_packet packet);
     32    void                SaveHeaderPacket(ogg_packet packet);
    3333    const std::vector<ogg_packet> & GetHeaderPackets();
    3434
    3535private:
    3636    std::vector<ogg_packet> fHeaderPackets;
    37     long        fSerialno;
     37    long                    fSerialno;
    3838};
    3939
    4040} } // namespace BPrivate::media

  • src/add-ons/media/plugins/ogg/OggSeekable.h

     
    2020                                     media_header *mediaHeader);
    2121
    2222protected:
    23                 OggSeekable(long serialno);
     23                        OggSeekable(long serialno);
    2424public:
    25     virtual     ~OggSeekable();
     25    virtual             ~OggSeekable();
    2626
    2727    // reader push input function
    28     status_t    AddPage(off_t position, const ogg_page & page);
     28    status_t            AddPage(off_t position, const ogg_page & page);
    2929
    30     void        SetLastPagePosition(off_t position);
    31     off_t       GetLastPagePosition();
     30    void                SetLastPagePosition(off_t position);
     31    off_t               GetLastPagePosition();
    3232private:
    3333    off_t               fLastPagePosition;
    3434
    3535protected:
    36     off_t       Seek(off_t position, int32 mode);
    37     off_t       Position(void) const;
    38     status_t    GetSize(off_t * size);
    39     status_t    ReadPage(ogg_page * page, int read_size = 4*B_PAGE_SIZE);
     36    off_t               Seek(off_t position, int32 mode);
     37    off_t               Position(void) const;
     38    status_t            GetSize(off_t * size);
     39    status_t            ReadPage(ogg_page * page, int read_size = 4*B_PAGE_SIZE);
    4040
    4141    // subclass pull input function
    42     status_t    GetPacket(ogg_packet * packet);
     42    status_t            GetPacket(ogg_packet * packet);
    4343
    4444protected:
    4545    int64               fCurrentFrame;

  • src/add-ons/media/plugins/ogg/OggTobiasSeekable.h

     
    99private:
    1010    typedef OggSeekable inherited;
    1111public:
    12     static bool IsValidHeader(const ogg_packet & packet);
     12    static bool         IsValidHeader(const ogg_packet & packet);
    1313public:
    14                 OggTobiasSeekable(long serialno);
    15     virtual     ~OggTobiasSeekable();
     14                        OggTobiasSeekable(long serialno);
     15    virtual             ~OggTobiasSeekable();
    1616
    1717    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1818                                      media_format *format);

  • src/add-ons/media/plugins/ogg/libogg/framing.c

     
    55 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
    66 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
    77 *                                                                  *
    8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
     8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
    99 * by the Xiph.Org Foundation http://www.xiph.org/                  *
    1010 *                                                                  *
    1111 ********************************************************************
    1212
    13  function: code raw [Vorbis] packets into framed OggSquish stream and
     13 function: code raw packets into framed OggSquish stream and
    1414           decode Ogg streams back into raw packets
    15  last mod: $Id: framing.c,v 1.2 2004/02/24 13:52:39 shatty Exp $
     15 last mod: $Id$
    1616
    1717 note: The CRC code is directly derived from public domain code by
    1818 Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html
    … …  
    2626
    2727/* A complete description of Ogg framing exists in docs/framing.html */
    2828
    29 int ogg_page_version(ogg_page *og){
     29int ogg_page_version(const ogg_page *og){
    3030  return((int)(og->header[4]));
    3131}
    3232
    33 int ogg_page_continued(ogg_page *og){
     33int ogg_page_continued(const ogg_page *og){
    3434  return((int)(og->header[5]&0x01));
    3535}
    3636
    37 int ogg_page_bos(ogg_page *og){
     37int ogg_page_bos(const ogg_page *og){
    3838  return((int)(og->header[5]&0x02));
    3939}
    4040
    41 int ogg_page_eos(ogg_page *og){
     41int ogg_page_eos(const ogg_page *og){
    4242  return((int)(og->header[5]&0x04));
    4343}
    4444
    45 ogg_int64_t ogg_page_granulepos(ogg_page *og){
     45ogg_int64_t ogg_page_granulepos(const ogg_page *og){
    4646  unsigned char *page=og->header;
    4747  ogg_int64_t granulepos=page[13]&(0xff);
    4848  granulepos= (granulepos<<8)|(page[12]&0xff);
    … …  
    5555  return(granulepos);
    5656}
    5757
    58 int ogg_page_serialno(ogg_page *og){
     58int ogg_page_serialno(const ogg_page *og){
    5959  return(og->header[14] |
    60     (og->header[15]<<8) |
    61     (og->header[16]<<16) |
    62     (og->header[17]<<24));
     60        (og->header[15]<<8) |
     61        (og->header[16]<<16) |
     62        (og->header[17]<<24));
    6363}
    6464 
    65 long ogg_page_pageno(ogg_page *og){
     65long ogg_page_pageno(const ogg_page *og){
    6666  return(og->header[18] |
    67     (og->header[19]<<8) |
    68     (og->header[20]<<16) |
    69     (og->header[21]<<24));
     67        (og->header[19]<<8) |
     68        (og->header[20]<<16) |
     69        (og->header[21]<<24));
    7070}
    7171
    7272
    … …  
    8888  ogg_page_continued(page) !=0
    8989*/
    9090
    91 int ogg_page_packets(ogg_page *og){
     91int ogg_page_packets(const ogg_page *og){
    9292  int i,n=og->header[26],count=0;
    9393  for(i=0;i<n;i++)
    9494    if(og->header[27+i]<255)count++;
    … …  
    108108  for (i=0; i<8; i++)
    109109    if (r & 0x80000000UL)
    110110      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 */
     111                                    polynomial, although we use an
     112                                    unreflected alg and an init/final
     113                                    of 0, not 0xffffffff */
    114114    else
    115115       r<<=1;
    116116 return (r & 0xffffffffUL);
    117117}
    118118#endif
    119119
    120 static ogg_uint32_t crc_lookup[256]={
     120static const ogg_uint32_t crc_lookup[256]={
    121121  0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
    122122  0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
    123123  0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
    … …  
    189189  if(os){
    190190    memset(os,0,sizeof(*os));
    191191    os->body_storage=16*1024;
     192    os->lacing_storage=1024;
     193
    192194    os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
    193 
    194     os->lacing_storage=1024;
    195195    os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
    196196    os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
    197197
     198    if(!os->body_data || !os->lacing_vals || !os->granule_vals){
     199      ogg_stream_clear(os);
     200      return -1;
     201    }
     202
    198203    os->serialno=serialno;
    199204
    200205    return(0);
    … …  
    202207  return(-1);
    203208}
    204209
     210/* async/delayed error detection for the ogg_stream_state */
     211int ogg_stream_check(ogg_stream_state *os){
     212  if(!os || !os->body_data) return -1;
     213  return 0;
     214}
     215
    205216/* _clear does not free os, only the non-flat storage within */
    206217int ogg_stream_clear(ogg_stream_state *os){
    207218  if(os){
    … …  
    225236/* Helpers for ogg_stream_encode; this keeps the structure and
    226237   what's happening fairly clear */
    227238
    228 static void _os_body_expand(ogg_stream_state *os,int needed){
     239static int _os_body_expand(ogg_stream_state *os,int needed){
    229240  if(os->body_storage<=os->body_fill+needed){
     241    void *ret;
     242    ret=_ogg_realloc(os->body_data,(os->body_storage+needed+1024)*
     243                     sizeof(*os->body_data));
     244    if(!ret){
     245      ogg_stream_clear(os);
     246      return -1;
     247    }
    230248    os->body_storage+=(needed+1024);
    231     os->body_data=_ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));
     249    os->body_data=ret;
    232250  }
     251  return 0;
    233252}
    234253
    235 static void _os_lacing_expand(ogg_stream_state *os,int needed){
     254static int _os_lacing_expand(ogg_stream_state *os,int needed){
    236255  if(os->lacing_storage<=os->lacing_fill+needed){
     256    void *ret;
     257    ret=_ogg_realloc(os->lacing_vals,(os->lacing_storage+needed+32)*
     258                     sizeof(*os->lacing_vals));
     259    if(!ret){
     260      ogg_stream_clear(os);
     261      return -1;
     262    }
     263    os->lacing_vals=ret;
     264    ret=_ogg_realloc(os->granule_vals,(os->lacing_storage+needed+32)*
     265                     sizeof(*os->granule_vals));
     266    if(!ret){
     267      ogg_stream_clear(os);
     268      return -1;
     269    }
     270    os->granule_vals=ret;
    237271    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));
    240272  }
     273  return 0;
    241274}
    242275
    243276/* checksum the page */
    … …  
    260293    for(i=0;i<og->body_len;i++)
    261294      crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
    262295   
    263     og->header[22]=crc_reg&0xff;
    264     og->header[23]=(crc_reg>>8)&0xff;
    265     og->header[24]=(crc_reg>>16)&0xff;
    266     og->header[25]=(crc_reg>>24)&0xff;
     296    og->header[22]=(unsigned char)(crc_reg&0xff);
     297    og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
     298    og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
     299    og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
    267300  }
    268301}
    269302
    270303/* 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;
     304int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count,
     305                       long e_o_s, ogg_int64_t granulepos){
    273306
     307  int bytes = 0, lacing_vals, i;
     308
     309  if(ogg_stream_check(os)) return -1;
     310  if(!iov) return 0;
     311 
     312  for (i = 0; i < count; ++i) bytes += (int)iov[i].iov_len;
     313  lacing_vals=bytes/255+1;
     314
    274315  if(os->body_returned){
    275316    /* advance packet data according to the body_returned pointer. We
    276317       had to keep it around to return a pointer into the buffer last
    … …  
    279320    os->body_fill-=os->body_returned;
    280321    if(os->body_fill)
    281322      memmove(os->body_data,os->body_data+os->body_returned,
    282           os->body_fill);
     323              os->body_fill);
    283324    os->body_returned=0;
    284325  }
    285326 
    286327  /* make sure we have the buffer storage */
    287   _os_body_expand(os,op->bytes);
    288   _os_lacing_expand(os,lacing_vals);
     328  if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals))
     329    return -1;
    289330
    290331  /* Copy in the submitted packet.  Yes, the copy is a waste; this is
    291332     the liability of overly clean abstraction for the time being.  It
    292333     will actually be fairly easy to eliminate the extra copy in the
    293334     future */
    294335
    295   memcpy(os->body_data+os->body_fill,op->packet,op->bytes);
    296   os->body_fill+=op->bytes;
     336  for (i = 0; i < count; ++i) {
     337    memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len);
     338    os->body_fill += (int)iov[i].iov_len;
     339  }
    297340
    298341  /* Store lacing vals for this packet */
    299342  for(i=0;i<lacing_vals-1;i++){
    300343    os->lacing_vals[os->lacing_fill+i]=255;
    301344    os->granule_vals[os->lacing_fill+i]=os->granulepos;
    302345  }
    303   os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;
    304   os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;
     346  os->lacing_vals[os->lacing_fill+i]=bytes%255;
     347  os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos;
    305348
    306349  /* flag the first segment as the beginning of the packet */
    307350  os->lacing_vals[os->lacing_fill]|= 0x100;
    … …  
    311354  /* for the sake of completeness */
    312355  os->packetno++;
    313356
    314   if(op->e_o_s)os->e_o_s=1;
     357  if(e_o_s)os->e_o_s=1;
    315358
    316359  return(0);
    317360}
    318361
     362int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
     363  ogg_iovec_t iov;
     364  iov.iov_base = op->packet;
     365  iov.iov_len = op->bytes;
     366  return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos);
     367}
     368
    319369/* This will flush remaining packets into a page (returning nonzero),
    320370   even if there is not enough data to trigger a flush normally
    321371   (undersized page). If there are no packets or partial packets to
    … …  
    336386  int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
    337387  int bytes=0;
    338388  long acc=0;
    339   ogg_int64_t granule_pos=os->granule_vals[0];
     389  ogg_int64_t granule_pos=-1;
    340390
    341   if(maxvals==0)return(0);
     391  if(ogg_stream_check(os)) return 0;
     392  if(maxvals==0)return 0;
    342393 
    343394  /* construct a page */
    344395  /* decide how many segments to include */
    … …  
    349400    granule_pos=0;
    350401    for(vals=0;vals<maxvals;vals++){
    351402      if((os->lacing_vals[vals]&0x0ff)<255){
    352     vals++;
    353     break;
     403        vals++;
     404        break;
    354405      }
    355406    }
    356407  }else{
    357408    for(vals=0;vals<maxvals;vals++){
    358409      if(acc>4096)break;
    359410      acc+=os->lacing_vals[vals]&0x0ff;
    360       granule_pos=os->granule_vals[vals];
     411      if((os->lacing_vals[vals]&0xff)<255)
     412        granule_pos=os->granule_vals[vals];
    361413    }
    362414  }
    363415 
    … …  
    378430
    379431  /* 64 bits of PCM position */
    380432  for(i=6;i<14;i++){
    381     os->header[i]=(granule_pos&0xff);
     433    os->header[i]=(unsigned char)(granule_pos&0xff);
    382434    granule_pos>>=8;
    383435  }
    384436
    … …  
    386438  {
    387439    long serialno=os->serialno;
    388440    for(i=14;i<18;i++){
    389       os->header[i]=(serialno&0xff);
     441      os->header[i]=(unsigned char)(serialno&0xff);
    390442      serialno>>=8;
    391443    }
    392444  }
    … …  
    394446  /* 32 bits of page counter (we have both counter and page header
    395447     because this val can roll over) */
    396448  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 */
     449                                     stream_reset; this would be a
     450                                     strange thing to do in an
     451                                     encode stream, but it has
     452                                     plausible uses */
    401453  {
    402454    long pageno=os->pageno++;
    403455    for(i=18;i<22;i++){
    404       os->header[i]=(pageno&0xff);
     456      os->header[i]=(unsigned char)(pageno&0xff);
    405457      pageno>>=8;
    406458    }
    407459  }
    … …  
    413465  os->header[25]=0;
    414466 
    415467  /* segment table */
    416   os->header[26]=vals&0xff;
     468  os->header[26]=(unsigned char)(vals&0xff);
    417469  for(i=0;i<vals;i++)
    418     bytes+=os->header[i+27]=(os->lacing_vals[i]&0xff);
     470    bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);
    419471 
    420472  /* set pointers in the ogg_page struct */
    421473  og->header=os->header;
    … …  
    444496good only until the next call (using the same ogg_stream_state) */
    445497
    446498int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
     499  if(ogg_stream_check(os)) return 0;
    447500
    448501  if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
    449502     os->body_fill-os->body_returned > 4096 ||/* 'page nominal size' case */
    … …  
    454507  }
    455508 
    456509  /* not enough data to construct a page and not end of stream */
    457   return(0);
     510  return 0;
    458511}
    459512
    460513int ogg_stream_eos(ogg_stream_state *os){
     514  if(ogg_stream_check(os)) return 1;
    461515  return os->e_o_s;
    462516}
    463517
    … …  
    474528   ogg_stream_pagein() along with the appropriate
    475529   ogg_stream_state* (ie, matching serialno).  We then get raw
    476530   packets out calling ogg_stream_packetout() with a
    477    ogg_stream_state.  See the 'frame-prog.txt' docs for details and
    478    example code. */
     531   ogg_stream_state. */
    479532
    480533/* initialize the struct to a known state */
    481534int ogg_sync_init(ogg_sync_state *oy){
    482535  if(oy){
     536    oy->storage = -1; /* used as a readiness flag */
    483537    memset(oy,0,sizeof(*oy));
    484538  }
    485539  return(0);
    … …  
    489543int ogg_sync_clear(ogg_sync_state *oy){
    490544  if(oy){
    491545    if(oy->data)_ogg_free(oy->data);
    492     ogg_sync_init(oy);
     546    memset(oy,0,sizeof(*oy));
    493547  }
    494548  return(0);
    495549}
    … …  
    502556  return(0);
    503557}
    504558
     559int ogg_sync_check(ogg_sync_state *oy){
     560  if(oy->storage<0) return -1;
     561  return 0;
     562}
     563
    505564char *ogg_sync_buffer(ogg_sync_state *oy, long size){
     565  if(ogg_sync_check(oy)) return NULL;
    506566
    507567  /* first, clear out any space that has been previously returned */
    508568  if(oy->returned){
    … …  
    515575  if(size>oy->storage-oy->fill){
    516576    /* We need to extend the internal buffer */
    517577    long newsize=size+oy->fill+4096; /* an extra page to be nice */
     578    void *ret;
    518579
    519580    if(oy->data)
    520       oy->data=_ogg_realloc(oy->data,newsize);
     581      ret=_ogg_realloc(oy->data,newsize);
    521582    else
    522       oy->data=_ogg_malloc(newsize);
     583      ret=_ogg_malloc(newsize);
     584    if(!ret){
     585      ogg_sync_clear(oy);
     586      return NULL;
     587    }
     588    oy->data=ret;
    523589    oy->storage=newsize;
    524590  }
    525591
    … …  
    528594}
    529595
    530596int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
    531   if(oy->fill+bytes>oy->storage)return(-1);
     597  if(ogg_sync_check(oy))return -1;
     598  if(oy->fill+bytes>oy->storage)return -1;
    532599  oy->fill+=bytes;
    533600  return(0);
    534601}
    … …  
    547614  unsigned char *page=oy->data+oy->returned;
    548615  unsigned char *next;
    549616  long bytes=oy->fill-oy->returned;
     617
     618  if(ogg_sync_check(oy))return 0;
    550619 
    551620  if(oy->headerbytes==0){
    552621    int headerbytes,i;
    … …  
    586655    /* Compare */
    587656    if(memcmp(chksum,page+22,4)){
    588657      /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page
    589     at all) */
     658        at all) */
    590659      /* replace the computed checksum with the one actually read in */
    591660      memcpy(page+22,chksum,4);
    592661     
    … …  
    624693  if(!next)
    625694    next=oy->data+oy->fill;
    626695
    627   oy->returned=next-oy->data;
    628   return(-(next-page));
     696  oy->returned=(int)(next-oy->data);
     697  return((long)-(next-page));
    629698}
    630699
    631700/* sync the stream and get a page.  Keep trying until we find a page.
    … …  
    641710
    642711int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
    643712
     713  if(ogg_sync_check(oy))return 0;
     714
    644715  /* all we need to do is verify a page at the head of the stream
    645716     buffer.  If it doesn't verify, we look for the next potential
    646717     frame */
    647718
    648   while(1){
     719  for(;;){
    649720    long ret=ogg_sync_pageseek(oy,og);
    650721    if(ret>0){
    651722      /* have a page */
    … …  
    685756  long pageno=ogg_page_pageno(og);
    686757  int segments=header[26];
    687758 
     759  if(ogg_stream_check(os)) return -1;
     760
    688761  /* clean up 'returned data' */
    689762  {
    690763    long lr=os->lacing_returned;
    … …  
    694767    if(br){
    695768      os->body_fill-=br;
    696769      if(os->body_fill)
    697     memmove(os->body_data,os->body_data+br,os->body_fill);
     770        memmove(os->body_data,os->body_data+br,os->body_fill);
    698771      os->body_returned=0;
    699772    }
    700773
    701774    if(lr){
    702775      /* segment table */
    703776      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));
     777        memmove(os->lacing_vals,os->lacing_vals+lr,
     778                (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
     779        memmove(os->granule_vals,os->granule_vals+lr,
     780                (os->lacing_fill-lr)*sizeof(*os->granule_vals));
    708781      }
    709782      os->lacing_fill-=lr;
    710783      os->lacing_packet-=lr;
    … …  
    716789  if(serialno!=os->serialno)return(-1);
    717790  if(version>0)return(-1);
    718791
    719   _os_lacing_expand(os,segments+1);
     792  if(_os_lacing_expand(os,segments+1)) return -1;
    720793
    721794  /* are we in sequence? */
    722795  if(pageno!=os->pageno){
    … …  
    732805      os->lacing_vals[os->lacing_fill++]=0x400;
    733806      os->lacing_packet++;
    734807    }
     808  }
    735809
    736     /* are we a 'continued packet' page?  If so, we'll need to skip
    737        some segments */
    738     if(continued){
     810  /* are we a 'continued packet' page?  If so, we may need to skip
     811     some segments */
     812  if(continued){
     813    if(os->lacing_fill<1 ||
     814       os->lacing_vals[os->lacing_fill-1]==0x400){
    739815      bos=0;
    740816      for(;segptr<segments;segptr++){
    741     int val=header[27+segptr];
    742     body+=val;
    743     bodysize-=val;
    744     if(val<255){
    745       segptr++;
    746       break;
    747     }
     817        int val=header[27+segptr];
     818        body+=val;
     819        bodysize-=val;
     820        if(val<255){
     821          segptr++;
     822          break;
     823        }
    748824      }
    749825    }
    750826  }
    751827 
    752828  if(bodysize){
    753     _os_body_expand(os,bodysize);
     829    if(_os_body_expand(os,bodysize)) return -1;
    754830    memcpy(os->body_data+os->body_fill,body,bodysize);
    755831    os->body_fill+=bodysize;
    756832  }
    … …  
    763839      os->granule_vals[os->lacing_fill]=-1;
    764840     
    765841      if(bos){
    766     os->lacing_vals[os->lacing_fill]|=0x100;
    767     bos=0;
     842        os->lacing_vals[os->lacing_fill]|=0x100;
     843        bos=0;
    768844      }
    769845     
    770846      if(val<255)saved=os->lacing_fill;
    … …  
    795871
    796872/* clear things to an initial state.  Good to call, eg, before seeking */
    797873int ogg_sync_reset(ogg_sync_state *oy){
     874  if(ogg_sync_check(oy))return -1;
     875
    798876  oy->fill=0;
    799877  oy->returned=0;
    800878  oy->unsynced=0;
    … …  
    804882}
    805883
    806884int ogg_stream_reset(ogg_stream_state *os){
     885  if(ogg_stream_check(os)) return -1;
     886
    807887  os->body_fill=0;
    808888  os->body_returned=0;
    809889
    … …  
    823903}
    824904
    825905int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
     906  if(ogg_stream_check(os)) return -1;
    826907  ogg_stream_reset(os);
    827908  os->serialno=serialno;
    828909  return(0);
    … …  
    883964}
    884965
    885966int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
     967  if(ogg_stream_check(os)) return 0;
    886968  return _packetout(os,op,1);
    887969}
    888970
    889971int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
     972  if(ogg_stream_check(os)) return 0;
    890973  return _packetout(os,op,0);
    891974}
    892975
    … …  
    9271010  lastno=no;
    9281011  if(op->packetno!=sequence){
    9291012    fprintf(stderr,"incorrect packet sequence %ld != %d\n",
    930         (long)(op->packetno),sequence);
     1013            (long)(op->packetno),sequence);
    9311014    exit(1);
    9321015  }
    9331016
    … …  
    9351018  for(j=0;j<op->bytes;j++)
    9361019    if(op->packet[j]!=((j+no)&0xff)){
    9371020      fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
    938           j,op->packet[j],(j+no)&0xff);
     1021              j,op->packet[j],(j+no)&0xff);
    9391022      exit(1);
    9401023    }
    9411024}
    … …  
    9461029  for(j=0;j<og->body_len;j++)
    9471030    if(og->body[j]!=data[j]){
    9481031      fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
    949           j,data[j],og->body[j]);
     1032              j,data[j],og->body[j]);
    9501033      exit(1);
    9511034    }
    9521035
    … …  
    9551038    if(og->header[j]!=header[j]){
    9561039      fprintf(stderr,"header content mismatch at pos %ld:\n",j);
    9571040      for(j=0;j<header[26]+27;j++)
    958     fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
     1041        fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
    9591042      fprintf(stderr,"\n");
    9601043      exit(1);
    9611044    }
    9621045  }
    9631046  if(og->header_len!=header[26]+27){
    9641047    fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
    965         og->header_len,header[26]+27);
     1048            og->header_len,header[26]+27);
    9661049    exit(1);
    9671050  }
    9681051}
    … …  
    9711054  int j;
    9721055  fprintf(stderr,"\nHEADER:\n");
    9731056  fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %x\n",
    974       og->header[0],og->header[1],og->header[2],og->header[3],
    975       (int)og->header[4],(int)og->header[5]);
     1057          og->header[0],og->header[1],og->header[2],og->header[3],
     1058          (int)og->header[4],(int)og->header[5]);
    9761059
    9771060  fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ld\n",
    978       (og->header[9]<<24)|(og->header[8]<<16)|
    979       (og->header[7]<<8)|og->header[6],
    980       (og->header[17]<<24)|(og->header[16]<<16)|
    981       (og->header[15]<<8)|og->header[14],
    982       ((long)(og->header[21])<<24)|(og->header[20]<<16)|
    983       (og->header[19]<<8)|og->header[18]);
     1061          (og->header[9]<<24)|(og->header[8]<<16)|
     1062          (og->header[7]<<8)|og->header[6],
     1063          (og->header[17]<<24)|(og->header[16]<<16)|
     1064          (og->header[15]<<8)|og->header[14],
     1065          ((long)(og->header[21])<<24)|(og->header[20]<<16)|
     1066          (og->header[19]<<8)|og->header[18]);
    9841067
    9851068  fprintf(stderr,"  checksum: %02x:%02x:%02x:%02x\n  segments: %d (",
    986       (int)og->header[22],(int)og->header[23],
    987       (int)og->header[24],(int)og->header[25],
    988       (int)og->header[26]);
     1069          (int)og->header[22],(int)og->header[23],
     1070          (int)og->header[24],(int)og->header[25],
     1071          (int)og->header[26]);
    9891072
    9901073  for(j=27;j<og->header_len;j++)
    9911074    fprintf(stderr,"%d ",(int)og->header[j]);
    … …  
    10021085  og->body=temp;
    10031086}
    10041087
     1088void free_page(ogg_page *og){
     1089  _ogg_free (og->header);
     1090  _ogg_free (og->body);
     1091}
     1092
    10051093void error(void){
    10061094  fprintf(stderr,"error!\n");
    10071095  exit(1);
    … …  
    10091097
    10101098/* 17 only */
    10111099const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
    1012                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1013                0x01,0x02,0x03,0x04,0,0,0,0,
    1014                0x15,0xed,0xec,0x91,
    1015                1,
    1016                17};
     1100                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1101                       0x01,0x02,0x03,0x04,0,0,0,0,
     1102                       0x15,0xed,0xec,0x91,
     1103                       1,
     1104                       17};
    10171105
    10181106/* 17, 254, 255, 256, 500, 510, 600 byte, pad */
    10191107const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1020                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1021                0x01,0x02,0x03,0x04,0,0,0,0,
    1022                0x59,0x10,0x6c,0x2c,
    1023                1,
    1024                17};
     1108                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1109                       0x01,0x02,0x03,0x04,0,0,0,0,
     1110                       0x59,0x10,0x6c,0x2c,
     1111                       1,
     1112                       17};
    10251113const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
    1026                0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
    1027                0x01,0x02,0x03,0x04,1,0,0,0,
    1028                0x89,0x33,0x85,0xce,
    1029                13,
    1030                254,255,0,255,1,255,245,255,255,0,
    1031                255,255,90};
     1114                       0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
     1115                       0x01,0x02,0x03,0x04,1,0,0,0,
     1116                       0x89,0x33,0x85,0xce,
     1117                       13,
     1118                       254,255,0,255,1,255,245,255,255,0,
     1119                       255,255,90};
    10321120
    10331121/* nil packets; beginning,middle,end */
    10341122const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1035                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1036                0x01,0x02,0x03,0x04,0,0,0,0,
    1037                0xff,0x7b,0x23,0x17,
    1038                1,
    1039                0};
     1123                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1124                       0x01,0x02,0x03,0x04,0,0,0,0,
     1125                       0xff,0x7b,0x23,0x17,
     1126                       1,
     1127                       0};
    10401128const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
    1041                0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
    1042                0x01,0x02,0x03,0x04,1,0,0,0,
    1043                0x5c,0x3f,0x66,0xcb,
    1044                17,
    1045                17,254,255,0,0,255,1,0,255,245,255,255,0,
    1046                255,255,90,0};
     1129                       0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
     1130                       0x01,0x02,0x03,0x04,1,0,0,0,
     1131                       0x5c,0x3f,0x66,0xcb,
     1132                       17,
     1133                       17,254,255,0,0,255,1,0,255,245,255,255,0,
     1134                       255,255,90,0};
    10471135
    10481136/* large initial packet */
    10491137const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1050                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1051                0x01,0x02,0x03,0x04,0,0,0,0,
    1052                0x01,0x27,0x31,0xaa,
    1053                18,
    1054                255,255,255,255,255,255,255,255,
    1055                255,255,255,255,255,255,255,255,255,10};
     1138                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1139                       0x01,0x02,0x03,0x04,0,0,0,0,
     1140                       0x01,0x27,0x31,0xaa,
     1141                       18,
     1142                       255,255,255,255,255,255,255,255,
     1143                       255,255,255,255,255,255,255,255,255,10};
    10561144
    10571145const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
    1058                0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
    1059                0x01,0x02,0x03,0x04,1,0,0,0,
    1060                0x7f,0x4e,0x8a,0xd2,
    1061                4,
    1062                255,4,255,0};
     1146                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
     1147                       0x01,0x02,0x03,0x04,1,0,0,0,
     1148                       0x7f,0x4e,0x8a,0xd2,
     1149                       4,
     1150                       255,4,255,0};
    10631151
    10641152
    10651153/* continuing packet test */
    10661154const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1067                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1068                0x01,0x02,0x03,0x04,0,0,0,0,
    1069                0xff,0x7b,0x23,0x17,
    1070                1,
    1071                0};
     1155                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1156                       0x01,0x02,0x03,0x04,0,0,0,0,
     1157                       0xff,0x7b,0x23,0x17,
     1158                       1,
     1159                       0};
    10721160
    10731161const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
    1074                0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1075                0x01,0x02,0x03,0x04,1,0,0,0,
    1076                0x34,0x24,0xd5,0x29,
    1077                17,
    1078                255,255,255,255,255,255,255,255,
    1079                255,255,255,255,255,255,255,255,255};
     1162                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
     1163                       0x01,0x02,0x03,0x04,1,0,0,0,
     1164                       0x54,0x05,0x51,0xc8,
     1165                       17,
     1166                       255,255,255,255,255,255,255,255,
     1167                       255,255,255,255,255,255,255,255,255};
    10801168
    10811169const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
    1082                0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
    1083                0x01,0x02,0x03,0x04,2,0,0,0,
    1084                0xc8,0xc3,0xcb,0xed,
    1085                5,
    1086                10,255,4,255,0};
     1170                       0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
     1171                       0x01,0x02,0x03,0x04,2,0,0,0,
     1172                       0xc8,0xc3,0xcb,0xed,
     1173                       5,
     1174                       10,255,4,255,0};
    10871175
    10881176
    10891177/* page with the 255 segment limit */
    10901178const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1091                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1092                0x01,0x02,0x03,0x04,0,0,0,0,
    1093                0xff,0x7b,0x23,0x17,
    1094                1,
    1095                0};
     1179                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1180                       0x01,0x02,0x03,0x04,0,0,0,0,
     1181                       0xff,0x7b,0x23,0x17,
     1182                       1,
     1183                       0};
    10961184
    10971185const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
    1098                0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
    1099                0x01,0x02,0x03,0x04,1,0,0,0,
    1100                0xed,0x2a,0x2e,0xa7,
    1101                255,
    1102                10,10,10,10,10,10,10,10,
    1103                10,10,10,10,10,10,10,10,
    1104                10,10,10,10,10,10,10,10,
    1105                10,10,10,10,10,10,10,10,
    1106                10,10,10,10,10,10,10,10,
    1107                10,10,10,10,10,10,10,10,
    1108                10,10,10,10,10,10,10,10,
    1109                10,10,10,10,10,10,10,10,
    1110                10,10,10,10,10,10,10,10,
    1111                10,10,10,10,10,10,10,10,
    1112                10,10,10,10,10,10,10,10,
    1113                10,10,10,10,10,10,10,10,
    1114                10,10,10,10,10,10,10,10,
    1115                10,10,10,10,10,10,10,10,
    1116                10,10,10,10,10,10,10,10,
    1117                10,10,10,10,10,10,10,10,
    1118                10,10,10,10,10,10,10,10,
    1119                10,10,10,10,10,10,10,10,
    1120                10,10,10,10,10,10,10,10,
    1121                10,10,10,10,10,10,10,10,
    1122                10,10,10,10,10,10,10,10,
    1123                10,10,10,10,10,10,10,10,
    1124                10,10,10,10,10,10,10,10,
    1125                10,10,10,10,10,10,10,10,
    1126                10,10,10,10,10,10,10,10,
    1127                10,10,10,10,10,10,10,10,
    1128                10,10,10,10,10,10,10,10,
    1129                10,10,10,10,10,10,10,10,
    1130                10,10,10,10,10,10,10,10,
    1131                10,10,10,10,10,10,10,10,
    1132                10,10,10,10,10,10,10,10,
    1133                10,10,10,10,10,10,10};
     1186                       0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
     1187                       0x01,0x02,0x03,0x04,1,0,0,0,
     1188                       0xed,0x2a,0x2e,0xa7,
     1189                       255,
     1190                       10,10,10,10,10,10,10,10,
     1191                       10,10,10,10,10,10,10,10,
     1192                       10,10,10,10,10,10,10,10,
     1193                       10,10,10,10,10,10,10,10,
     1194                       10,10,10,10,10,10,10,10,
     1195                       10,10,10,10,10,10,10,10,
     1196                       10,10,10,10,10,10,10,10,
     1197                       10,10,10,10,10,10,10,10,
     1198                       10,10,10,10,10,10,10,10,
     1199                       10,10,10,10,10,10,10,10,
     1200                       10,10,10,10,10,10,10,10,
     1201                       10,10,10,10,10,10,10,10,
     1202                       10,10,10,10,10,10,10,10,
     1203                       10,10,10,10,10,10,10,10,
     1204                       10,10,10,10,10,10,10,10,
     1205                       10,10,10,10,10,10,10,10,
     1206                       10,10,10,10,10,10,10,10,
     1207                       10,10,10,10,10,10,10,10,
     1208                       10,10,10,10,10,10,10,10,
     1209                       10,10,10,10,10,10,10,10,
     1210                       10,10,10,10,10,10,10,10,
     1211                       10,10,10,10,10,10,10,10,
     1212                       10,10,10,10,10,10,10,10,
     1213                       10,10,10,10,10,10,10,10,
     1214                       10,10,10,10,10,10,10,10,
     1215                       10,10,10,10,10,10,10,10,
     1216                       10,10,10,10,10,10,10,10,
     1217                       10,10,10,10,10,10,10,10,
     1218                       10,10,10,10,10,10,10,10,
     1219                       10,10,10,10,10,10,10,10,
     1220                       10,10,10,10,10,10,10,10,
     1221                       10,10,10,10,10,10,10};
    11341222
    11351223const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
    1136                0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
    1137                0x01,0x02,0x03,0x04,2,0,0,0,
    1138                0x6c,0x3b,0x82,0x3d,
    1139                1,
    1140                50};
     1224                       0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
     1225                       0x01,0x02,0x03,0x04,2,0,0,0,
     1226                       0x6c,0x3b,0x82,0x3d,
     1227                       1,
     1228                       50};
    11411229
    11421230
    11431231/* packet that overspans over an entire page */
    11441232const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1145                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1146                0x01,0x02,0x03,0x04,0,0,0,0,
    1147                0xff,0x7b,0x23,0x17,
    1148                1,
    1149                0};
     1233                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1234                       0x01,0x02,0x03,0x04,0,0,0,0,
     1235                       0xff,0x7b,0x23,0x17,
     1236                       1,
     1237                       0};
    11501238
    11511239const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
    1152                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
    1153                0x01,0x02,0x03,0x04,1,0,0,0,
    1154                0x3c,0xd9,0x4d,0x3f,
    1155                17,
    1156                100,255,255,255,255,255,255,255,255,
    1157                255,255,255,255,255,255,255,255};
     1240                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
     1241                       0x01,0x02,0x03,0x04,1,0,0,0,
     1242                       0x3c,0xd9,0x4d,0x3f,
     1243                       17,
     1244                       100,255,255,255,255,255,255,255,255,
     1245                       255,255,255,255,255,255,255,255};
    11581246
    11591247const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
    1160                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
    1161                0x01,0x02,0x03,0x04,2,0,0,0,
    1162                0xbd,0xd5,0xb5,0x8b,
    1163                17,
    1164                255,255,255,255,255,255,255,255,
    1165                255,255,255,255,255,255,255,255,255};
     1248                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
     1249                       0x01,0x02,0x03,0x04,2,0,0,0,
     1250                       0x01,0xd2,0xe5,0xe5,
     1251                       17,
     1252                       255,255,255,255,255,255,255,255,
     1253                       255,255,255,255,255,255,255,255,255};
    11661254
    11671255const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
    1168                0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
    1169                0x01,0x02,0x03,0x04,3,0,0,0,
    1170                0xef,0xdd,0x88,0xde,
    1171                7,
    1172                255,255,75,255,4,255,0};
     1256                       0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
     1257                       0x01,0x02,0x03,0x04,3,0,0,0,
     1258                       0xef,0xdd,0x88,0xde,
     1259                       7,
     1260                       255,255,75,255,4,255,0};
    11731261
    11741262/* packet that overspans over an entire page */
    11751263const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
    1176                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    1177                0x01,0x02,0x03,0x04,0,0,0,0,
    1178                0xff,0x7b,0x23,0x17,
    1179                1,
    1180                0};
     1264                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     1265                       0x01,0x02,0x03,0x04,0,0,0,0,
     1266                       0xff,0x7b,0x23,0x17,
     1267                       1,
     1268                       0};
    11811269
    11821270const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
    1183                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
    1184                0x01,0x02,0x03,0x04,1,0,0,0,
    1185                0x3c,0xd9,0x4d,0x3f,
    1186                17,
    1187                100,255,255,255,255,255,255,255,255,
    1188                255,255,255,255,255,255,255,255};
     1271                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
     1272                       0x01,0x02,0x03,0x04,1,0,0,0,
     1273                       0x3c,0xd9,0x4d,0x3f,
     1274                       17,
     1275                       100,255,255,255,255,255,255,255,255,
     1276                       255,255,255,255,255,255,255,255};
    11891277
    11901278const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
    1191                0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
    1192                0x01,0x02,0x03,0x04,2,0,0,0,
    1193                0xd4,0xe0,0x60,0xe5,
    1194                1,0};
     1279                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
     1280                       0x01,0x02,0x03,0x04,2,0,0,0,
     1281                       0xd4,0xe0,0x60,0xe5,
     1282                       1,0};
    11951283
    1196 void test_pack(const int *pl, const int **headers){
     1284void test_pack(const int *pl, const int **headers, int byteskip,
     1285               int pageskip, int packetskip){
    11971286  unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */
    11981287  long inptr=0;
    11991288  long outptr=0;
    12001289  long deptr=0;
    12011290  long depacket=0;
    12021291  long granule_pos=7,pageno=0;
    1203   int i,j,packets,pageout=0;
     1292  int i,j,packets,pageout=pageskip;
    12041293  int eosflag=0;
    12051294  int bosflag=0;
    12061295
     1296  int byteskipcount=0;
     1297
    12071298  ogg_stream_reset(&os_en);
    12081299  ogg_stream_reset(&os_de);
    12091300  ogg_sync_reset(&oy);
    12101301
     1302  for(packets=0;packets<packetskip;packets++)
     1303    depacket+=pl[packets];
     1304
    12111305  for(packets=0;;packets++)if(pl[packets]==-1)break;
    12121306
    12131307  for(i=0;i<packets;i++){
    … …  
    12321326      ogg_page og;
    12331327     
    12341328      while(ogg_stream_pageout(&os_en,&og)){
    1235     /* We have a page.  Check it carefully */
     1329        /* We have a page.  Check it carefully */
    12361330
    1237     fprintf(stderr,"%ld, ",pageno);
     1331        fprintf(stderr,"%ld, ",pageno);
    12381332
    1239     if(headers[pageno]==NULL){
    1240       fprintf(stderr,"coded too many pages!\n");
    1241       exit(1);
    1242     }
     1333        if(headers[pageno]==NULL){
     1334          fprintf(stderr,"coded too many pages!\n");
     1335          exit(1);
     1336        }
    12431337
    1244     check_page(data+outptr,headers[pageno],&og);
     1338        check_page(data+outptr,headers[pageno],&og);
    12451339
    1246     outptr+=og.body_len;
    1247     pageno++;
     1340        outptr+=og.body_len;
     1341        pageno++;
     1342        if(pageskip){
     1343          bosflag=1;
     1344          pageskip--;
     1345          deptr+=og.body_len;
     1346        }
    12481347
    1249     /* have a complete page; submit it to sync/decode */
     1348        /* have a complete page; submit it to sync/decode */
    12501349
    1251     {
    1252       ogg_page og_de;
    1253       ogg_packet op_de,op_de2;
    1254       char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
    1255       memcpy(buf,og.header,og.header_len);
    1256       memcpy(buf+og.header_len,og.body,og.body_len);
    1257       ogg_sync_wrote(&oy,og.header_len+og.body_len);
     1350        {
     1351          ogg_page og_de;
     1352          ogg_packet op_de,op_de2;
     1353          char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
     1354          char *next=buf;
     1355          byteskipcount+=og.header_len;
     1356          if(byteskipcount>byteskip){
     1357            memcpy(next,og.header,byteskipcount-byteskip);
     1358            next+=byteskipcount-byteskip;
     1359            byteskipcount=byteskip;
     1360          }
    12581361
    1259       while(ogg_sync_pageout(&oy,&og_de)>0){
    1260         /* got a page.  Happy happy.  Verify that it's good. */
    1261        
    1262         check_page(data+deptr,headers[pageout],&og_de);
    1263         deptr+=og_de.body_len;
    1264         pageout++;
     1362          byteskipcount+=og.body_len;
     1363          if(byteskipcount>byteskip){
     1364            memcpy(next,og.body,byteskipcount-byteskip);
     1365            next+=byteskipcount-byteskip;
     1366            byteskipcount=byteskip;
     1367          }
    12651368
    1266         /* submit it to deconstitution */
    1267         ogg_stream_pagein(&os_de,&og_de);
     1369          ogg_sync_wrote(&oy,next-buf);
    12681370
    1269         /* packets out? */
    1270         while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
    1271           ogg_stream_packetpeek(&os_de,NULL);
    1272           ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
    1273          
    1274           /* verify peek and out match */
    1275           if(memcmp(&op_de,&op_de2,sizeof(op_de))){
    1276         fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
    1277             depacket);
    1278         exit(1);
    1279           }
     1371          while(1){
     1372            int ret=ogg_sync_pageout(&oy,&og_de);
     1373            if(ret==0)break;
     1374            if(ret<0)continue;
     1375            /* got a page.  Happy happy.  Verify that it's good. */
     1376           
     1377            fprintf(stderr,"(%ld), ",pageout);
    12801378
    1281           /* verify the packet! */
    1282           /* check data */
    1283           if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
    1284         fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
    1285             depacket);
    1286         exit(1);
    1287           }
    1288           /* check bos flag */
    1289           if(bosflag==0 && op_de.b_o_s==0){
    1290         fprintf(stderr,"b_o_s flag not set on packet!\n");
    1291         exit(1);
    1292           }
    1293           if(bosflag && op_de.b_o_s){
    1294         fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
    1295         exit(1);
    1296           }
    1297           bosflag=1;
    1298           depacket+=op_de.bytes;
    1299          
    1300           /* check eos flag */
    1301           if(eosflag){
    1302         fprintf(stderr,"Multiple decoded packets with eos flag!\n");
    1303         exit(1);
    1304           }
     1379            check_page(data+deptr,headers[pageout],&og_de);
     1380            deptr+=og_de.body_len;
     1381            pageout++;
    13051382
    1306           if(op_de.e_o_s)eosflag=1;
     1383            /* submit it to deconstitution */
     1384            ogg_stream_pagein(&os_de,&og_de);
    13071385
    1308           /* check granulepos flag */
    1309           if(op_de.granulepos!=-1){
    1310         fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
    1311           }
    1312         }
    1313       }
    1314     }
     1386            /* packets out? */
     1387            while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
     1388              ogg_stream_packetpeek(&os_de,NULL);
     1389              ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
     1390             
     1391              /* verify peek and out match */
     1392              if(memcmp(&op_de,&op_de2,sizeof(op_de))){
     1393                fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
     1394                        depacket);
     1395                exit(1);
     1396              }
     1397
     1398              /* verify the packet! */
     1399              /* check data */
     1400              if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
     1401                fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
     1402                        depacket);
     1403                exit(1);
     1404              }
     1405              /* check bos flag */
     1406              if(bosflag==0 && op_de.b_o_s==0){
     1407                fprintf(stderr,"b_o_s flag not set on packet!\n");
     1408                exit(1);
     1409              }
     1410              if(bosflag && op_de.b_o_s){
     1411                fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
     1412                exit(1);
     1413              }
     1414              bosflag=1;
     1415              depacket+=op_de.bytes;
     1416             
     1417              /* check eos flag */
     1418              if(eosflag){
     1419                fprintf(stderr,"Multiple decoded packets with eos flag!\n");
     1420                exit(1);
     1421              }
     1422
     1423              if(op_de.e_o_s)eosflag=1;
     1424
     1425              /* check granulepos flag */
     1426              if(op_de.granulepos!=-1){
     1427                fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
     1428              }
     1429            }
     1430          }
     1431        }
    13151432      }
    13161433    }
    13171434  }
    … …  
    13581475    const int *headret[]={head1_0,NULL};
    13591476   
    13601477    fprintf(stderr,"testing single page encoding... ");
    1361     test_pack(packets,headret);
     1478    test_pack(packets,headret,0,0,0);
    13621479  }
    13631480
    13641481  {
    … …  
    13671484    const int *headret[]={head1_1,head2_1,NULL};
    13681485   
    13691486    fprintf(stderr,"testing basic page encoding... ");
    1370     test_pack(packets,headret);
     1487    test_pack(packets,headret,0,0,0);
    13711488  }
    13721489
    13731490  {
    … …  
    13761493    const int *headret[]={head1_2,head2_2,NULL};
    13771494   
    13781495    fprintf(stderr,"testing basic nil packets... ");
    1379     test_pack(packets,headret);
     1496    test_pack(packets,headret,0,0,0);
    13801497  }
    13811498
    13821499  {
    … …  
    13851502    const int *headret[]={head1_3,head2_3,NULL};
    13861503   
    13871504    fprintf(stderr,"testing initial-packet lacing > 4k... ");
    1388     test_pack(packets,headret);
     1505    test_pack(packets,headret,0,0,0);
    13891506  }
    13901507
    13911508  {
    … …  
    13941511    const int *headret[]={head1_4,head2_4,head3_4,NULL};
    13951512   
    13961513    fprintf(stderr,"testing single packet page span... ");
    1397     test_pack(packets,headret);
     1514    test_pack(packets,headret,0,0,0);
    13981515  }
    13991516
    14001517  /* page with the 255 segment limit */
    14011518  {
    14021519
    14031520    const int packets[]={0,10,10,10,10,10,10,10,10,
    1404            10,10,10,10,10,10,10,10,
    1405            10,10,10,10,10,10,10,10,
    1406            10,10,10,10,10,10,10,10,
    1407            10,10,10,10,10,10,10,10,
    1408            10,10,10,10,10,10,10,10,
    1409            10,10,10,10,10,10,10,10,
    1410            10,10,10,10,10,10,10,10,
    1411            10,10,10,10,10,10,10,10,
    1412            10,10,10,10,10,10,10,10,
    1413            10,10,10,10,10,10,10,10,
    1414            10,10,10,10,10,10,10,10,
    1415            10,10,10,10,10,10,10,10,
    1416            10,10,10,10,10,10,10,10,
    1417            10,10,10,10,10,10,10,10,
    1418            10,10,10,10,10,10,10,10,
    1419            10,10,10,10,10,10,10,10,
    1420            10,10,10,10,10,10,10,10,
    1421            10,10,10,10,10,10,10,10,
    1422            10,10,10,10,10,10,10,10,
    1423            10,10,10,10,10,10,10,10,
    1424            10,10,10,10,10,10,10,10,
    1425            10,10,10,10,10,10,10,10,
    1426            10,10,10,10,10,10,10,10,
    1427            10,10,10,10,10,10,10,10,
    1428            10,10,10,10,10,10,10,10,
    1429            10,10,10,10,10,10,10,10,
    1430            10,10,10,10,10,10,10,10,
    1431            10,10,10,10,10,10,10,10,
    1432            10,10,10,10,10,10,10,10,
    1433            10,10,10,10,10,10,10,10,
    1434            10,10,10,10,10,10,10,50,-1};
     1521                   10,10,10,10,10,10,10,10,
     1522                   10,10,10,10,10,10,10,10,
     1523                   10,10,10,10,10,10,10,10,
     1524                   10,10,10,10,10,10,10,10,
     1525                   10,10,10,10,10,10,10,10,
     1526                   10,10,10,10,10,10,10,10,
     1527                   10,10,10,10,10,10,10,10,
     1528                   10,10,10,10,10,10,10,10,
     1529                   10,10,10,10,10,10,10,10,
     1530                   10,10,10,10,10,10,10,10,
     1531                   10,10,10,10,10,10,10,10,
     1532                   10,10,10,10,10,10,10,10,
     1533                   10,10,10,10,10,10,10,10,
     1534                   10,10,10,10,10,10,10,10,
     1535                   10,10,10,10,10,10,10,10,
     1536                   10,10,10,10,10,10,10,10,
     1537                   10,10,10,10,10,10,10,10,
     1538                   10,10,10,10,10,10,10,10,
     1539                   10,10,10,10,10,10,10,10,
     1540                   10,10,10,10,10,10,10,10,
     1541                   10,10,10,10,10,10,10,10,
     1542                   10,10,10,10,10,10,10,10,
     1543                   10,10,10,10,10,10,10,10,
     1544                   10,10,10,10,10,10,10,10,
     1545                   10,10,10,10,10,10,10,10,
     1546                   10,10,10,10,10,10,10,10,
     1547                   10,10,10,10,10,10,10,10,
     1548                   10,10,10,10,10,10,10,10,
     1549                   10,10,10,10,10,10,10,10,
     1550                   10,10,10,10,10,10,10,10,
     1551                   10,10,10,10,10,10,10,50,-1};
    14351552    const int *headret[]={head1_5,head2_5,head3_5,NULL};
    14361553   
    14371554    fprintf(stderr,"testing max packet segments... ");
    1438     test_pack(packets,headret);
     1555    test_pack(packets,headret,0,0,0);
    14391556  }
    14401557
    14411558  {
    … …  
    14441561    const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
    14451562   
    14461563    fprintf(stderr,"testing very large packets... ");
    1447     test_pack(packets,headret);
     1564    test_pack(packets,headret,0,0,0);
    14481565  }
    14491566
    14501567  {
     1568    /* test for the libogg 1.1.1 resync in large continuation bug
     1569       found by Josh Coalson)  */
     1570    const int packets[]={0,100,9000,259,255,-1};
     1571    const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
     1572   
     1573    fprintf(stderr,"testing continuation resync in very large packets... ");
     1574    test_pack(packets,headret,100,2,3);
     1575  }
     1576
     1577  {
    14511578    /* term only page.  why not? */
    14521579    const int packets[]={0,100,4080,-1};
    14531580    const int *headret[]={head1_7,head2_7,head3_7,NULL};
    14541581   
    14551582    fprintf(stderr,"testing zero data page (1 nil packet)... ");
    1456     test_pack(packets,headret);
     1583    test_pack(packets,headret,0,0,0);
    14571584  }
    14581585
    14591586
    … …  
    14851612    /* retrieve finished pages */
    14861613    for(i=0;i<5;i++){
    14871614      if(ogg_stream_pageout(&os_en,&og[i])==0){
    1488     fprintf(stderr,"Too few pages output building sync tests!\n");
    1489     exit(1);
     1615        fprintf(stderr,"Too few pages output building sync tests!\n");
     1616        exit(1);
    14901617      }
    14911618      copy_page(&og[i]);
    14921619    }
    … …  
    15011628      ogg_sync_reset(&oy);
    15021629      ogg_stream_reset(&os_de);
    15031630      for(i=0;i<5;i++){
    1504     memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
    1505            og[i].header_len);
    1506     ogg_sync_wrote(&oy,og[i].header_len);
    1507     memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
    1508     ogg_sync_wrote(&oy,og[i].body_len);
     1631        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
     1632               og[i].header_len);
     1633        ogg_sync_wrote(&oy,og[i].header_len);
     1634        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
     1635        ogg_sync_wrote(&oy,og[i].body_len);
    15091636      }
    15101637
    15111638      ogg_sync_pageout(&oy,&temp);
    … …  
    15261653      if(ogg_stream_packetout(&os_de,&test)!=1)error();
    15271654      checkpacket(&test,4079,2,3000);
    15281655      if(ogg_stream_packetout(&os_de,&test)!=-1){
    1529     fprintf(stderr,"Error: loss of page did not return error\n");
    1530     exit(1);
     1656        fprintf(stderr,"Error: loss of page did not return error\n");
     1657        exit(1);
    15311658      }
    15321659      if(ogg_stream_packetout(&os_de,&test)!=1)error();
    15331660      checkpacket(&test,76,5,-1);
    … …  
    15461673      ogg_sync_reset(&oy);
    15471674      ogg_stream_reset(&os_de);
    15481675      for(i=0;i<5;i++){
    1549     memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
    1550            og[i].header_len);
    1551     ogg_sync_wrote(&oy,og[i].header_len);
    1552     memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
    1553     ogg_sync_wrote(&oy,og[i].body_len);
     1676        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
     1677               og[i].header_len);
     1678        ogg_sync_wrote(&oy,og[i].header_len);
     1679        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
     1680        ogg_sync_wrote(&oy,og[i].body_len);
    15541681      }
    15551682
    15561683      ogg_sync_pageout(&oy,&temp);
    … …  
    15751702      if(ogg_stream_packetout(&os_de,&test)!=1)error();
    15761703      checkpacket(&test,2956,3,4000);
    15771704      if(ogg_stream_packetout(&os_de,&test)!=-1){
    1578     fprintf(stderr,"Error: loss of page did not return error\n");
    1579     exit(1);
     1705        fprintf(stderr,"Error: loss of page did not return error\n");
     1706        exit(1);
    15801707      }
    15811708      if(ogg_stream_packetout(&os_de,&test)!=1)error();
    15821709      checkpacket(&test,300,13,14000);
    … …  
    15901717      fprintf(stderr,"Testing sync on partial inputs... ");
    15911718      ogg_sync_reset(&oy);
    15921719      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
    1593          3);
     1720             3);
    15941721      ogg_sync_wrote(&oy,3);
    15951722      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    15961723     
    15971724      /* Test fractional page inputs: incomplete fixed header */
    15981725      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
    1599          20);
     1726             20);
    16001727      ogg_sync_wrote(&oy,20);
    16011728      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16021729     
    16031730      /* Test fractional page inputs: incomplete header */
    16041731      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
    1605          5);
     1732             5);
    16061733      ogg_sync_wrote(&oy,5);
    16071734      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16081735     
    16091736      /* Test fractional page inputs: incomplete body */
    16101737     
    16111738      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
    1612          og[1].header_len-28);
     1739             og[1].header_len-28);
    16131740      ogg_sync_wrote(&oy,og[1].header_len-28);
    16141741      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16151742     
    … …  
    16181745      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16191746     
    16201747      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
    1621          og[1].body_len-1000);
     1748             og[1].body_len-1000);
    16221749      ogg_sync_wrote(&oy,og[1].body_len-1000);
    16231750      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    16241751     
    … …  
    16321759      ogg_sync_reset(&oy);
    16331760
    16341761      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
    1635          og[1].header_len);
     1762             og[1].header_len);
    16361763      ogg_sync_wrote(&oy,og[1].header_len);
    16371764
    16381765      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
    1639          og[1].body_len);
     1766             og[1].body_len);
    16401767      ogg_sync_wrote(&oy,og[1].body_len);
    16411768
    16421769      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
    1643          20);
     1770             20);
    16441771      ogg_sync_wrote(&oy,20);
    16451772      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    16461773      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16471774
    16481775      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
    1649          og[1].header_len-20);
     1776             og[1].header_len-20);
    16501777      ogg_sync_wrote(&oy,og[1].header_len-20);
    16511778      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
    1652          og[1].body_len);
     1779             og[1].body_len);
    16531780      ogg_sync_wrote(&oy,og[1].body_len);
    16541781      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    16551782
    … …  
    16641791     
    16651792      /* 'garbage' */
    16661793      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
    1667          og[1].body_len);
     1794             og[1].body_len);
    16681795      ogg_sync_wrote(&oy,og[1].body_len);
    16691796
    16701797      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
    1671          og[1].header_len);
     1798             og[1].header_len);
    16721799      ogg_sync_wrote(&oy,og[1].header_len);
    16731800
    16741801      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
    1675          og[1].body_len);
     1802             og[1].body_len);
    16761803      ogg_sync_wrote(&oy,og[1].body_len);
    16771804
    16781805      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
    1679          20);
     1806             20);
    16801807      ogg_sync_wrote(&oy,20);
    16811808      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16821809      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    16831810      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    16841811
    16851812      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
    1686          og[2].header_len-20);
     1813             og[2].header_len-20);
    16871814      ogg_sync_wrote(&oy,og[2].header_len-20);
    16881815      memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
    1689          og[2].body_len);
     1816             og[2].body_len);
    16901817      ogg_sync_wrote(&oy,og[2].body_len);
    16911818      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    16921819
    … …  
    17001827      ogg_sync_reset(&oy);
    17011828
    17021829      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
    1703          og[1].header_len);
     1830             og[1].header_len);
    17041831      ogg_sync_wrote(&oy,og[1].header_len);
    17051832
    17061833      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
    1707          og[1].body_len);
     1834             og[1].body_len);
    17081835      ogg_sync_wrote(&oy,og[1].body_len);
    17091836
    17101837      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
    1711          og[2].header_len);
     1838             og[2].header_len);
    17121839      ogg_sync_wrote(&oy,og[2].header_len);
    17131840
    17141841      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
    1715          og[2].header_len);
     1842             og[2].header_len);
    17161843      ogg_sync_wrote(&oy,og[2].header_len);
    17171844
    17181845      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
    17191846
    17201847      memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
    1721          og[2].body_len-5);
     1848             og[2].body_len-5);
    17221849      ogg_sync_wrote(&oy,og[2].body_len-5);
    17231850
    17241851      memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
    1725          og[3].header_len);
     1852             og[3].header_len);
    17261853      ogg_sync_wrote(&oy,og[3].header_len);
    17271854
    17281855      memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
    1729          og[3].body_len);
     1856             og[3].body_len);
    17301857      ogg_sync_wrote(&oy,og[3].body_len);
    17311858
    17321859      if(ogg_sync_pageout(&oy,&og_de)>0)error();
    … …  
    17341861
    17351862      fprintf(stderr,"ok.\n");
    17361863    }
     1864
     1865    /* Free page data that was previously copied */
     1866    {
     1867      for(i=0;i<5;i++){
     1868        free_page(&og[i]);
     1869      }
     1870    }
    17371871  }   
    17381872
    17391873  return(0);

  • src/add-ons/media/plugins/ogg/libogg/bitwise.c

     
    55 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
    66 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
    77 *                                                                  *
    8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
     8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
    99 * by the Xiph.Org Foundation http://www.xiph.org/                  *
    1010 *                                                                  *
    1111 ********************************************************************
    1212
    1313  function: packing variable sized words into an octet stream
    14   last mod: $Id: bitwise.c,v 1.2 2004/02/24 13:52:39 shatty Exp $
     14  last mod: $Id$
    1515
    1616 ********************************************************************/
    1717
    … …  
    2424
    2525#define BUFFER_INCREMENT 256
    2626
    27 static unsigned long mask[]=
     27static const unsigned long mask[]=
    2828{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
    2929 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
    3030 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
    … …  
    3333 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
    3434 0x3fffffff,0x7fffffff,0xffffffff };
    3535
    36 static unsigned int mask8B[]=
     36static const unsigned int mask8B[]=
    3737{0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
    3838
    3939void oggpack_writeinit(oggpack_buffer *b){
    … …  
    4747  oggpack_writeinit(b);
    4848}
    4949
     50int oggpack_writecheck(oggpack_buffer *b){
     51  if(!b->ptr || !b->storage)return -1;
     52  return 0;
     53}
     54
     55int oggpackB_writecheck(oggpack_buffer *b){
     56  return oggpack_writecheck(b);
     57}
     58
    5059void oggpack_writetrunc(oggpack_buffer *b,long bits){
    5160  long bytes=bits>>3;
    52   bits-=bytes*8;
    53   b->ptr=b->buffer+bytes;
    54   b->endbit=bits;
    55   b->endbyte=bytes;
    56   *b->ptr&=mask[bits];
     61  if(b->ptr){
     62    bits-=bytes*8;
     63    b->ptr=b->buffer+bytes;
     64    b->endbit=bits;
     65    b->endbyte=bytes;
     66    *b->ptr&=mask[bits];
     67  }
    5768}
    5869
    5970void oggpackB_writetrunc(oggpack_buffer *b,long bits){
    6071  long bytes=bits>>3;
    61   bits-=bytes*8;
    62   b->ptr=b->buffer+bytes;
    63   b->endbit=bits;
    64   b->endbyte=bytes;
    65   *b->ptr&=mask8B[bits];
     72  if(b->ptr){
     73    bits-=bytes*8;
     74    b->ptr=b->buffer+bytes;
     75    b->endbit=bits;
     76    b->endbyte=bytes;
     77    *b->ptr&=mask8B[bits];
     78  }
    6679}
    6780
    6881/* Takes only up to 32 bits. */
    6982void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
    7083  if(b->endbyte+4>=b->storage){
    71     b->buffer=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
     84    void *ret;
     85    if(!b->ptr)return;
     86    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
     87    if(!ret){
     88      oggpack_writeclear(b);
     89      return;
     90    }
     91    b->buffer=ret;
    7292    b->storage+=BUFFER_INCREMENT;
    7393    b->ptr=b->buffer+b->endbyte;
    7494  }
    … …  
    7999  b->ptr[0]|=value<<b->endbit; 
    80100 
    81101  if(bits>=8){
    82     b->ptr[1]=value>>(8-b->endbit); 
     102    b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
    83103    if(bits>=16){
    84       b->ptr[2]=value>>(16-b->endbit); 
     104      b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
    85105      if(bits>=24){
    86     b->ptr[3]=value>>(24-b->endbit); 
    87     if(bits>=32){
    88       if(b->endbit)
    89         b->ptr[4]=value>>(32-b->endbit);
    90       else
    91         b->ptr[4]=0;
    92     }
     106        b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
     107        if(bits>=32){
     108          if(b->endbit)
     109            b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
     110          else
     111            b->ptr[4]=0;
     112        }
    93113      }
    94114    }
    95115  }
    … …  
    102122/* Takes only up to 32 bits. */
    103123void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
    104124  if(b->endbyte+4>=b->storage){
    105     b->buffer=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
     125    void *ret;
     126    if(!b->ptr)return;
     127    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
     128    if(!ret){
     129      oggpack_writeclear(b);
     130      return;
     131    }
     132    b->buffer=ret;
    106133    b->storage+=BUFFER_INCREMENT;
    107134    b->ptr=b->buffer+b->endbyte;
    108135  }
    … …  
    113140  b->ptr[0]|=value>>(24+b->endbit); 
    114141 
    115142  if(bits>=8){
    116     b->ptr[1]=value>>(16+b->endbit); 
     143    b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
    117144    if(bits>=16){
    118       b->ptr[2]=value>>(8+b->endbit); 
     145      b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
    119146      if(bits>=24){
    120     b->ptr[3]=value>>(b->endbit); 
    121     if(bits>=32){
    122       if(b->endbit)
    123         b->ptr[4]=value<<(8-b->endbit);
    124       else
    125         b->ptr[4]=0;
    126     }
     147        b->ptr[3]=(unsigned char)(value>>(b->endbit));
     148        if(bits>=32){
     149          if(b->endbit)
     150            b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
     151          else
     152            b->ptr[4]=0;
     153        }
    127154      }
    128155    }
    129156  }
    … …  
    146173}
    147174
    148175static void oggpack_writecopy_helper(oggpack_buffer *b,
    149                      void *source,
    150                      long bits,
    151                      void (*w)(oggpack_buffer *,
    152                            unsigned long,
    153                            int),
    154                      int msb){
     176                                     void *source,
     177                                     long bits,
     178                                     void (*w)(oggpack_buffer *,
     179                                               unsigned long,
     180                                               int),
     181                                     int msb){
    155182  unsigned char *ptr=(unsigned char *)source;
    156183
    157184  long bytes=bits/8;
    … …  
    165192  }else{
    166193    /* aligned block copy */
    167194    if(b->endbyte+bytes+1>=b->storage){
     195      void *ret;
     196      if(!b->ptr)return;
    168197      b->storage=b->endbyte+bytes+BUFFER_INCREMENT;
    169       b->buffer=_ogg_realloc(b->buffer,b->storage);
     198      ret=_ogg_realloc(b->buffer,b->storage);
     199      if(!ret){
     200        oggpack_writeclear(b);
     201        return;
     202      }
     203      b->buffer=ret;
    170204      b->ptr=b->buffer+b->endbyte;
    171205    }
    172206
    173207    memmove(b->ptr,source,bytes);
    174208    b->ptr+=bytes;
    175     b->buffer+=bytes;
     209    b->endbyte+=bytes;
    176210    *b->ptr=0;
    177211
    178212  }
    … …  
    193227}
    194228
    195229void oggpack_reset(oggpack_buffer *b){
     230  if(!b->ptr)return;
    196231  b->ptr=b->buffer;
    197232  b->buffer[0]=0;
    198233  b->endbit=b->endbyte=0;
    … …  
    203238}
    204239
    205240void oggpack_writeclear(oggpack_buffer *b){
    206   _ogg_free(b->buffer);
     241  if(b->buffer)_ogg_free(b->buffer);
    207242  memset(b,0,sizeof(*b));
    208243}
    209244
    … …  
    239274    if(bits>16){
    240275      ret|=b->ptr[2]<<(16-b->endbit); 
    241276      if(bits>24){
    242     ret|=b->ptr[3]<<(24-b->endbit); 
    243     if(bits>32 && b->endbit)
    244       ret|=b->ptr[4]<<(32-b->endbit);
     277        ret|=b->ptr[3]<<(24-b->endbit); 
     278        if(bits>32 && b->endbit)
     279          ret|=b->ptr[4]<<(32-b->endbit);
    245280      }
    246281    }
    247282  }
    … …  
    266301    if(bits>16){
    267302      ret|=b->ptr[2]<<(8+b->endbit); 
    268303      if(bits>24){
    269     ret|=b->ptr[3]<<(b->endbit); 
    270     if(bits>32 && b->endbit)
    271       ret|=b->ptr[4]>>(8-b->endbit);
     304        ret|=b->ptr[3]<<(b->endbit); 
     305        if(bits>32 && b->endbit)
     306          ret|=b->ptr[4]>>(8-b->endbit);
    272307      }
    273308    }
    274309  }
    275   return (ret>>(m>>1))>>((m+1)>>1);
     310  return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
    276311}
    277312
    278313long oggpack_look1(oggpack_buffer *b){
    … …  
    310345
    311346/* bits <= 32 */
    312347long oggpack_read(oggpack_buffer *b,int bits){
    313   unsigned long ret;
     348  long ret;
    314349  unsigned long m=mask[bits];
    315350
    316351  bits+=b->endbit;
    317352
    318353  if(b->endbyte+4>=b->storage){
    319354    /* not the main path */
    320     ret=-1UL;
     355    ret=-1L;
    321356    if(b->endbyte*8+bits>b->storage*8)goto overflow;
    322357  }
    323358 
    … …  
    327362    if(bits>16){
    328363      ret|=b->ptr[2]<<(16-b->endbit); 
    329364      if(bits>24){
    330     ret|=b->ptr[3]<<(24-b->endbit); 
    331     if(bits>32 && b->endbit){
    332       ret|=b->ptr[4]<<(32-b->endbit);
    333     }
     365        ret|=b->ptr[3]<<(24-b->endbit); 
     366        if(bits>32 && b->endbit){
     367          ret|=b->ptr[4]<<(32-b->endbit);
     368        }
    334369      }
    335370    }
    336371  }
    … …  
    346381
    347382/* bits <= 32 */
    348383long oggpackB_read(oggpack_buffer *b,int bits){
    349   unsigned long ret;
     384  long ret;
    350385  long m=32-bits;
    351386 
    352387  bits+=b->endbit;
    353388
    354389  if(b->endbyte+4>=b->storage){
    355390    /* not the main path */
    356     ret=-1UL;
     391    ret=-1L;
    357392    if(b->endbyte*8+bits>b->storage*8)goto overflow;
     393    /* special case to avoid reading b->ptr[0], which might be past the end of
     394        the buffer; also skips some useless accounting */
     395    else if(!bits)return(0L);
    358396  }
    359397 
    360398  ret=b->ptr[0]<<(24+b->endbit);
    … …  
    363401    if(bits>16){
    364402      ret|=b->ptr[2]<<(8+b->endbit); 
    365403      if(bits>24){
    366     ret|=b->ptr[3]<<(b->endbit); 
    367     if(bits>32 && b->endbit)
    368       ret|=b->ptr[4]>>(8-b->endbit);
     404        ret|=b->ptr[3]<<(b->endbit); 
     405        if(bits>32 && b->endbit)
     406          ret|=b->ptr[4]>>(8-b->endbit);
    369407      }
    370408    }
    371409  }
    372   ret=(ret>>(m>>1))>>((m+1)>>1);
     410  ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
    373411 
    374412 overflow:
    375413
    … …  
    380418}
    381419
    382420long oggpack_read1(oggpack_buffer *b){
    383   unsigned long ret;
     421  long ret;
    384422 
    385423  if(b->endbyte>=b->storage){
    386424    /* not the main path */
    387     ret=-1UL;
     425    ret=-1L;
    388426    goto overflow;
    389427  }
    390428
    … …  
    402440}
    403441
    404442long oggpackB_read1(oggpack_buffer *b){
    405   unsigned long ret;
     443  long ret;
    406444 
    407445  if(b->endbyte>=b->storage){
    408446    /* not the main path */
    409     ret=-1UL;
     447    ret=-1L;
    410448    goto overflow;
    411449  }
    412450
    … …  
    493531      report("looked at incorrect value!\n");
    494532    if(tbit==1)
    495533      if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
    496     report("looked at single bit incorrect value!\n");
     534        report("looked at single bit incorrect value!\n");
    497535    if(tbit==1){
    498536      if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
    499     report("read incorrect single bit value!\n");
     537        report("read incorrect single bit value!\n");
    500538    }else{
    501539    if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
    502540      report("read incorrect value!\n");
    … …  
    528566      report("looked at incorrect value!\n");
    529567    if(tbit==1)
    530568      if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
    531     report("looked at single bit incorrect value!\n");
     569        report("looked at single bit incorrect value!\n");
    532570    if(tbit==1){
    533571      if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
    534     report("read incorrect single bit value!\n");
     572        report("read incorrect single bit value!\n");
    535573    }else{
    536574    if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
    537575      report("read incorrect value!\n");
    … …  
    569607                    34,242,223,136,35,222,211,86,171,50,225,135,214,75,172,
    570608                    223,4};
    571609  static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222,
    572                8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
    573                245,251,128};
     610                       8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
     611                       245,251,128};
    574612
    575613  int twosize=6;
    576614  static int two[6]={61,255,255,251,231,29};
    … …  
    582620                      58,135,196,61,55,129,183,54,101,100,170,37,127,126,10,
    583621                      100,52,4,14,18,86,77,1};
    584622  static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183,
    585             130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
    586             233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
    587             200,20,254,4,58,106,176,144,0};
     623                        130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
     624                        233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
     625                        200,20,254,4,58,106,176,144,0};
    588626
    589627  int foursize=38;
    590628  static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72,
    591629                     132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169,
    592630                     28,2,133,0,1};
    593631  static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41,
    594             1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
    595             129,10,4,32};
     632                        1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
     633                        129,10,4,32};
    596634
    597635  int fivesize=45;
    598636  static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62,
    599637                     241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169,
    600638                     84,75,159,2,1,0,132,192,8,0,0,18,22};
    601639  static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226,
    602             124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
    603             172,150,169,129,79,128,0,6,4,32,0,27,9,0};
     640                        124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
     641                        172,150,169,129,79,128,0,6,4,32,0,27,9,0};
    604642
    605643  int sixsize=7;
    606644  static int six[7]={17,177,170,242,169,19,148};
    … …  
    633671    if(oggpack_look(&r,32)==-1)report("out of data. failed!");
    634672    if(oggpack_look(&r,32)!=large[i]){
    635673      fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i],
    636           oggpack_look(&r,32),large[i]);
     674              oggpack_look(&r,32),large[i]);
    637675      report("read incorrect value!\n");
    638676    }
    639677    oggpack_adv(&r,32);
    … …  
    687725    fprintf(stderr,"failed; read past end without -1.\n");
    688726      exit(1);
    689727  }
     728  oggpack_writeclear(&o);
    690729  fprintf(stderr,"ok.\n");
    691730
    692731  /********** lazy, cut-n-paste retest with MSb packing ***********/
    … …  
    718757    if(oggpackB_look(&r,32)==-1)report("out of data. failed!");
    719758    if(oggpackB_look(&r,32)!=large[i]){
    720759      fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i],
    721           oggpackB_look(&r,32),large[i]);
     760              oggpackB_look(&r,32),large[i]);
    722761      report("read incorrect value!\n");
    723762    }
    724763    oggpackB_adv(&r,32);
    … …  
    772811    fprintf(stderr,"failed; read past end without -1.\n");
    773812      exit(1);
    774813  }
     814  oggpackB_writeclear(&o);
    775815  fprintf(stderr,"ok.\n\n");
    776816
    777817

  • src/add-ons/media/plugins/ogg/libogg/ogg/ogg.h

     
    55 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
    66 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
    77 *                                                                  *
    8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
     8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007             *
    99 * by the Xiph.Org Foundation http://www.xiph.org/                  *
    1010 *                                                                  *
    1111 ********************************************************************
    1212
    1313 function: toplevel libogg include
    14  last mod: $Id: ogg.h,v 1.2 2004/02/24 13:52:39 shatty Exp $
     14 last mod: $Id$
    1515
    1616 ********************************************************************/
    1717#ifndef _OGG_H
    … …  
    2121extern "C" {
    2222#endif
    2323
     24#include <stddef.h>
    2425#include <ogg/os_types.h>
    2526
    2627typedef struct {
     28  void *iov_base;
     29  size_t iov_len;
     30} ogg_iovec_t;
     31
     32typedef struct {
    2733  long endbyte;
    2834  int  endbit;
    2935
    … …  
    5359
    5460  int     *lacing_vals;      /* The values that will go to the segment table */
    5561  ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
    56                 this way, but it is simple coupled to the
    57                 lacing fifo */
     62                                this way, but it is simple coupled to the
     63                                lacing fifo */
    5864  long    lacing_storage;
    5965  long    lacing_fill;
    6066  long    lacing_packet;
    … …  
    6975                             of a logical bitstream */
    7076  long    serialno;
    7177  long    pageno;
    72   ogg_int64_t  packetno;      /* sequence number for decode; the framing
     78  ogg_int64_t  packetno;  /* sequence number for decode; the framing
    7379                             knows where there's a hole in the data,
    7480                             but we need coupling so that the codec
    7581                             (which is in a seperate abstraction
    … …  
    8894  long  e_o_s;
    8995
    9096  ogg_int64_t  granulepos;
    91  
     97
    9298  ogg_int64_t  packetno;     /* sequence number for decode; the framing
    93                 knows where there's a hole in the data,
    94                 but we need coupling so that the codec
    95                 (which is in a seperate abstraction
    96                 layer) also knows about the gap */
     99                                knows where there's a hole in the data,
     100                                but we need coupling so that the codec
     101                                (which is in a seperate abstraction
     102                                layer) also knows about the gap */
    97103} ogg_packet;
    98104
    99105typedef struct {
    … …  
    110116/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
    111117
    112118extern void  oggpack_writeinit(oggpack_buffer *b);
     119extern int   oggpack_writecheck(oggpack_buffer *b);
    113120extern void  oggpack_writetrunc(oggpack_buffer *b,long bits);
    114121extern void  oggpack_writealign(oggpack_buffer *b);
    115122extern void  oggpack_writecopy(oggpack_buffer *b,void *source,long bits);
    … …  
    128135extern unsigned char *oggpack_get_buffer(oggpack_buffer *b);
    129136
    130137extern void  oggpackB_writeinit(oggpack_buffer *b);
     138extern int   oggpackB_writecheck(oggpack_buffer *b);
    131139extern void  oggpackB_writetrunc(oggpack_buffer *b,long bits);
    132140extern void  oggpackB_writealign(oggpack_buffer *b);
    133141extern void  oggpackB_writecopy(oggpack_buffer *b,void *source,long bits);
    … …  
    148156/* Ogg BITSTREAM PRIMITIVES: encoding **************************/
    149157
    150158extern int      ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op);
     159extern int      ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov,
     160                                   int count, long e_o_s, ogg_int64_t granulepos);
    151161extern int      ogg_stream_pageout(ogg_stream_state *os, ogg_page *og);
    152162extern int      ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
    153163
    … …  
    156166extern int      ogg_sync_init(ogg_sync_state *oy);
    157167extern int      ogg_sync_clear(ogg_sync_state *oy);
    158168extern int      ogg_sync_reset(ogg_sync_state *oy);
    159 extern int  ogg_sync_destroy(ogg_sync_state *oy);
     169extern int      ogg_sync_destroy(ogg_sync_state *oy);
     170extern int      ogg_sync_check(ogg_sync_state *oy);
    160171
    161172extern char    *ogg_sync_buffer(ogg_sync_state *oy, long size);
    162173extern int      ogg_sync_wrote(ogg_sync_state *oy, long bytes);
    … …  
    173184extern int      ogg_stream_reset(ogg_stream_state *os);
    174185extern int      ogg_stream_reset_serialno(ogg_stream_state *os,int serialno);
    175186extern int      ogg_stream_destroy(ogg_stream_state *os);
     187extern int      ogg_stream_check(ogg_stream_state *os);
    176188extern int      ogg_stream_eos(ogg_stream_state *os);
    177189
    178190extern void     ogg_page_checksum_set(ogg_page *og);
    179191
    180 extern int      ogg_page_version(ogg_page *og);
    181 extern int      ogg_page_continued(ogg_page *og);
    182 extern int      ogg_page_bos(ogg_page *og);
    183 extern int      ogg_page_eos(ogg_page *og);
    184 extern ogg_int64_t  ogg_page_granulepos(ogg_page *og);
    185 extern int      ogg_page_serialno(ogg_page *og);
    186 extern long     ogg_page_pageno(ogg_page *og);
    187 extern int      ogg_page_packets(ogg_page *og);
     192extern int      ogg_page_version(const ogg_page *og);
     193extern int      ogg_page_continued(const ogg_page *og);
     194extern int      ogg_page_bos(const ogg_page *og);
     195extern int      ogg_page_eos(const ogg_page *og);
     196extern ogg_int64_t  ogg_page_granulepos(const ogg_page *og);
     197extern int      ogg_page_serialno(const ogg_page *og);
     198extern long     ogg_page_pageno(const ogg_page *og);
     199extern int      ogg_page_packets(const ogg_page *og);
    188200
    189201extern void     ogg_packet_clear(ogg_packet *op);
    190202
    … …  
    194206#endif
    195207
    196208#endif  /* _OGG_H */
    197 
    198 
    199 
    200 
    201 
    202 

  • src/add-ons/media/plugins/ogg/libogg/ogg/os_types.h

     
    2424#define _ogg_realloc realloc
    2525#define _ogg_free    free
    2626
    27 #ifdef _WIN32
     27#if defined(_WIN32)
    2828
    29 #  ifndef __GNUC__
    30    /* MSVC/Borland */
    31    typedef __int64 ogg_int64_t;
    32    typedef __int32 ogg_int32_t;
    33    typedef unsigned __int32 ogg_uint32_t;
    34    typedef __int16 ogg_int16_t;
    35    typedef unsigned __int16 ogg_uint16_t;
     29#  if defined(__CYGWIN__)
     30#    include <stdint.h>
     31     typedef int16_t ogg_int16_t;
     32     typedef uint16_t ogg_uint16_t;
     33     typedef int32_t ogg_int32_t;
     34     typedef uint32_t ogg_uint32_t;
     35     typedef int64_t ogg_int64_t;
     36     typedef uint64_t ogg_uint64_t;
     37#  elif defined(__MINGW32__)
     38#    include <sys/types.h>
     39     typedef short ogg_int16_t;
     40     typedef unsigned short ogg_uint16_t;
     41     typedef int ogg_int32_t;
     42     typedef unsigned int ogg_uint32_t;
     43     typedef long long ogg_int64_t;
     44     typedef unsigned long long ogg_uint64_t;
     45#  elif defined(__MWERKS__)
     46     typedef long long ogg_int64_t;
     47     typedef int ogg_int32_t;
     48     typedef unsigned int ogg_uint32_t;
     49     typedef short ogg_int16_t;
     50     typedef unsigned short ogg_uint16_t;
    3651#  else
    37    /* Cygwin */
    38    #include <_G_config.h>
    39    typedef _G_int64_t ogg_int64_t;
    40    typedef _G_int32_t ogg_int32_t;
    41    typedef _G_uint32_t ogg_uint32_t;
    42    typedef _G_int16_t ogg_int16_t;
    43    typedef _G_uint16_t ogg_uint16_t;
     52     /* MSVC/Borland */
     53     typedef __int64 ogg_int64_t;
     54     typedef __int32 ogg_int32_t;
     55     typedef unsigned __int32 ogg_uint32_t;
     56     typedef __int16 ogg_int16_t;
     57     typedef unsigned __int16 ogg_uint16_t;
    4458#  endif
    4559
    4660#elif defined(__MACOS__)
    … …  
    5266   typedef UInt32 ogg_uint32_t;
    5367   typedef SInt64 ogg_int64_t;
    5468
    55 #elif defined(__MACOSX__) /* MacOS X Framework build */
     69#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
    5670
    5771#  include <sys/types.h>
    5872   typedef int16_t ogg_int16_t;
    … …  
    6175   typedef u_int32_t ogg_uint32_t;
    6276   typedef int64_t ogg_int64_t;
    6377
    64 #elif (defined(__BEOS__) || defined(__HAIKU__))
     78#elif defined(__HAIKU__)
    6579
     80  /* Haiku */
     81#  include <sys/types.h>
     82   typedef short ogg_int16_t;
     83   typedef unsigned short ogg_uint16_t;
     84   typedef int ogg_int32_t;
     85   typedef unsigned int ogg_uint32_t;
     86   typedef long long ogg_int64_t;
     87
     88#elif defined(__BEOS__)
     89
    6690   /* Be */
    6791#  include <inttypes.h>
    6892   typedef int16_t ogg_int16_t;
    … …  
    96120   typedef unsigned ogg_uint32_t;
    97121   typedef short ogg_int16_t;
    98122
     123#elif defined(__SYMBIAN32__)
     124
     125   /* Symbian GCC */
     126   typedef signed short ogg_int16_t;
     127   typedef unsigned short ogg_uint16_t;
     128   typedef signed int ogg_int32_t;
     129   typedef unsigned int ogg_uint32_t;
     130   typedef long long int ogg_int64_t;
     131
    99132#else
    100133
    101134#  include <sys/types.h>

  • src/add-ons/media/plugins/ogg/OggSpeexSeekable.h

     
    99private:
    1010    typedef OggSeekable inherited;
    1111public:
    12     static bool IsValidHeader(const ogg_packet & packet);
     12    static bool         IsValidHeader(const ogg_packet & packet);
    1313public:
    14                 OggSpeexSeekable(long serialno);
    15     virtual     ~OggSpeexSeekable();
     14                        OggSpeexSeekable(long serialno);
     15    virtual             ~OggSpeexSeekable();
    1616
    1717    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1818                                      media_format *format);

  • src/add-ons/media/plugins/ogg/OggVorbisStream.h

     
    77
    88class OggVorbisStream : public OggStream {
    99public:
    10     static bool IsValidHeader(const ogg_packet & packet);
     10    static bool         IsValidHeader(const ogg_packet & packet);
    1111public:
    12                 OggVorbisStream(long serialno);
    13     virtual     ~OggVorbisStream();
     12                        OggVorbisStream(long serialno);
     13    virtual             ~OggVorbisStream();
    1414
    1515    virtual status_t    GetStreamInfo(int64 *frameCount, bigtime_t *duration,
    1616                                      media_format *format);

  • src/add-ons/media/plugins/ogg/OggReaderPlugin.h

     
    5757public:
    5858    class StreamInterface {
    5959    public:
    60         virtual         ~StreamInterface() {};
     60        virtual             ~StreamInterface() {};
    6161        virtual ssize_t     ReadPage() = 0;
    6262    };
    6363};

  • src/add-ons/media/plugins/ogg/OggStream.h

     
    1919                                     media_header *mediaHeader);
    2020
    2121protected:
    22                 OggStream(long serialno);
     22                        OggStream(long serialno);
    2323public:
    24     virtual     ~OggStream();
     24    virtual             ~OggStream();
    2525
    2626    // reader push input function
    2727    virtual status_t    AddPage(off_t position, const ogg_page & page);
    2828
    2929protected:
    3030    // subclass pull input function
    31     status_t    GetPacket(ogg_packet * packet);
     31    status_t            GetPacket(ogg_packet * packet);
    3232    ogg_packet          fChunkPacket;
    3333
    3434protected: