DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4685 Commits
9 Branches
356MB
Tree: c20a61b802
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c20a61b802'
${ noResults }
JUCE/modules/juce_audio_formats/codecs/oggvorbis/framing.c

1797 lines
51KB
Raw Blame History 

  1. /********************************************************************

  2.  *                                                                  *

  3.  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *

  4.  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *

  5.  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *

  6.  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *

  7.  *                                                                  *

  8.  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *

  9.  * by the Xiph.Org Foundation http://www.xiph.org/                  *

  10.  *                                                                  *

  11.  ********************************************************************

  12. 

  13.  function: code raw [Vorbis] packets into framed OggSquish stream and

  14.            decode Ogg streams back into raw packets

  15.  last mod: $Id: framing.c,v 1.1 2007/06/07 17:48:18 jules_rms Exp $

  16. 

  17.  note: The CRC code is directly derived from public domain code by

  18.  Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html

  19.  for details.

  20. 

  21.  ********************************************************************/

  22. 

  23. #include <stdlib.h>

  24. #include <string.h>

  25. #include "ogg.h"

  26. 

  27. /* A complete description of Ogg framing exists in docs/framing.html */

  28. 

  29. int ogg_page_version(ogg_page *og){

  30.   return((int)(og->header[4]));

  31. }

  32. 

  33. int ogg_page_continued(ogg_page *og){

  34.   return((int)(og->header[5]&0x01));

  35. }

  36. 

  37. int ogg_page_bos(ogg_page *og){

  38.   return((int)(og->header[5]&0x02));

  39. }

  40. 

  41. int ogg_page_eos(ogg_page *og){

  42.   return((int)(og->header[5]&0x04));

  43. }

  44. 

  45. ogg_int64_t ogg_page_granulepos(ogg_page *og){

  46.   unsigned char *page=og->header;

  47.   ogg_int64_t granulepos=page[13]&(0xff);

  48.   granulepos= (granulepos<<8)|(page[12]&0xff);

  49.   granulepos= (granulepos<<8)|(page[11]&0xff);

  50.   granulepos= (granulepos<<8)|(page[10]&0xff);

  51.   granulepos= (granulepos<<8)|(page[9]&0xff);

  52.   granulepos= (granulepos<<8)|(page[8]&0xff);

  53.   granulepos= (granulepos<<8)|(page[7]&0xff);

  54.   granulepos= (granulepos<<8)|(page[6]&0xff);

  55.   return(granulepos);

  56. }

  57. 

  58. int ogg_page_serialno(ogg_page *og){

  59.   return(og->header[14] |

  60. 	 (og->header[15]<<8) |

  61. 	 (og->header[16]<<16) |

  62. 	 (og->header[17]<<24));

  63. }

  64. 

  65. long ogg_page_pageno(ogg_page *og){

  66.   return(og->header[18] |

  67. 	 (og->header[19]<<8) |

  68. 	 (og->header[20]<<16) |

  69. 	 (og->header[21]<<24));

  70. }

  71. 

  72. 

  73. 

  74. /* returns the number of packets that are completed on this page (if

  75.    the leading packet is begun on a previous page, but ends on this

  76.    page, it's counted */

  77. 

  78. /* NOTE:

  79. If a page consists of a packet begun on a previous page, and a new

  80. packet begun (but not completed) on this page, the return will be:

  81.   ogg_page_packets(page)   ==1,

  82.   ogg_page_continued(page) !=0

  83. 

  84. If a page happens to be a single packet that was begun on a

  85. previous page, and spans to the next page (in the case of a three or

  86. more page packet), the return will be:

  87.   ogg_page_packets(page)   ==0,

  88.   ogg_page_continued(page) !=0

  89. */

  90. 

  91. int ogg_page_packets(ogg_page *og){

  92.   int i,n=og->header[26],count=0;

  93.   for(i=0;i<n;i++)

  94.     if(og->header[27+i]<255)count++;

  95.   return(count);

  96. }

  97. 

  98. 

  99. #if 0

  100. /* helper to initialize lookup for direct-table CRC (illustrative; we

  101.    use the static init below) */

  102. 

  103. static ogg_uint32_t _ogg_crc_entry(unsigned long index){

  104.   int           i;

  105.   unsigned long r;

  106. 

  107.   r = index << 24;

  108.   for (i=0; i<8; i++)

  109.     if (r & 0x80000000UL)

  110.       r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator

  111. 				    polynomial, although we use an

  112. 				    unreflected alg and an init/final

  113. 				    of 0, not 0xffffffff */

  114.     else

  115.        r<<=1;

  116.  return (r & 0xffffffffUL);

  117. }

  118. #endif

  119. 

  120. static const ogg_uint32_t crc_lookup[256]={

  121.   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,

  122.   0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,

  123.   0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,

  124.   0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,

  125.   0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,

  126.   0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,

  127.   0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,

  128.   0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,

  129.   0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,

  130.   0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,

  131.   0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,

  132.   0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,

  133.   0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,

  134.   0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,

  135.   0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,

  136.   0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,

  137.   0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,

  138.   0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,

  139.   0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,

  140.   0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,

  141.   0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,

  142.   0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,

  143.   0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,

  144.   0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,

  145.   0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,

  146.   0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,

  147.   0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,

  148.   0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,

  149.   0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,

  150.   0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,

  151.   0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,

  152.   0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,

  153.   0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,

  154.   0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,

  155.   0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,

  156.   0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,

  157.   0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,

  158.   0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,

  159.   0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,

  160.   0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,

  161.   0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,

  162.   0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,

  163.   0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,

  164.   0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,

  165.   0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,

  166.   0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,

  167.   0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,

  168.   0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,

  169.   0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,

  170.   0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,

  171.   0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,

  172.   0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,

  173.   0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,

  174.   0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,

  175.   0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,

  176.   0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,

  177.   0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,

  178.   0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,

  179.   0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,

  180.   0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,

  181.   0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,

  182.   0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,

  183.   0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,

  184.   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};

  185. 

  186. /* init the encode/decode logical stream state */

  187. 

  188. int ogg_stream_init(ogg_stream_state *os,int serialno){

  189.   if(os){

  190.     memset(os,0,sizeof(*os));

  191.     os->body_storage=16*1024;

  192.     os->body_data=(unsigned char*) _ogg_malloc(os->body_storage*sizeof(*os->body_data));

  193. 

  194.     os->lacing_storage=1024;

  195.     os->lacing_vals=(int*) _ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));

  196.     os->granule_vals=(ogg_int64_t*) _ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));

  197. 

  198.     os->serialno=serialno;

  199. 

  200.     return(0);

  201.   }

  202.   return(-1);

  203. }

  204. 

  205. /* _clear does not free os, only the non-flat storage within */

  206. int ogg_stream_clear(ogg_stream_state *os){

  207.   if(os){

  208.     if(os->body_data)_ogg_free(os->body_data);

  209.     if(os->lacing_vals)_ogg_free(os->lacing_vals);

  210.     if(os->granule_vals)_ogg_free(os->granule_vals);

  211. 

  212.     memset(os,0,sizeof(*os));

  213.   }

  214.   return(0);

  215. }

  216. 

  217. int ogg_stream_destroy(ogg_stream_state *os){

  218.   if(os){

  219.     ogg_stream_clear(os);

  220.     _ogg_free(os);

  221.   }

  222.   return(0);

  223. }

  224. 

  225. /* Helpers for ogg_stream_encode; this keeps the structure and

  226.    what's happening fairly clear */

  227. 

  228. static void _os_body_expand(ogg_stream_state *os,int needed){

  229.   if(os->body_storage<=os->body_fill+needed){

  230.     os->body_storage+=(needed+1024);

  231.     os->body_data=(unsigned char*) _ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));

  232.   }

  233. }

  234. 

  235. static void _os_lacing_expand(ogg_stream_state *os,int needed){

  236.   if(os->lacing_storage<=os->lacing_fill+needed){

  237.     os->lacing_storage+=(needed+32);

  238.     os->lacing_vals=(int*)_ogg_realloc(os->lacing_vals,os->lacing_storage*sizeof(*os->lacing_vals));

  239.     os->granule_vals=(ogg_int64_t*)_ogg_realloc(os->granule_vals,os->lacing_storage*sizeof(*os->granule_vals));

  240.   }

  241. }

  242. 

  243. /* checksum the page */

  244. /* Direct table CRC; note that this will be faster in the future if we

  245.    perform the checksum silmultaneously with other copies */

  246. 

  247. void ogg_page_checksum_set(ogg_page *og){

  248.   if(og){

  249.     ogg_uint32_t crc_reg=0;

  250.     int i;

  251. 

  252.     /* safety; needed for API behavior, but not framing code */

  253.     og->header[22]=0;

  254.     og->header[23]=0;

  255.     og->header[24]=0;

  256.     og->header[25]=0;

  257. 

  258.     for(i=0;i<og->header_len;i++)

  259.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];

  260.     for(i=0;i<og->body_len;i++)

  261.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];

  262. 

  263.     og->header[22]=(unsigned char)(crc_reg&0xff);

  264.     og->header[23]=(unsigned char)((crc_reg>>8)&0xff);

  265.     og->header[24]=(unsigned char)((crc_reg>>16)&0xff);

  266.     og->header[25]=(unsigned char)((crc_reg>>24)&0xff);

  267.   }

  268. }

  269. 

  270. /* submit data to the internal buffer of the framing engine */

  271. int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){

  272.   int lacing_vals=op->bytes/255+1,i;

  273. 

  274.   if(os->body_returned){

  275.     /* advance packet data according to the body_returned pointer. We

  276.        had to keep it around to return a pointer into the buffer last

  277.        call */

  278. 

  279.     os->body_fill-=os->body_returned;

  280.     if(os->body_fill)

  281.       memmove(os->body_data,os->body_data+os->body_returned,

  282. 	      os->body_fill);

  283.     os->body_returned=0;

  284.   }

  285. 

  286.   /* make sure we have the buffer storage */

  287.   _os_body_expand(os,op->bytes);

  288.   _os_lacing_expand(os,lacing_vals);

  289. 

  290.   /* Copy in the submitted packet.  Yes, the copy is a waste; this is

  291.      the liability of overly clean abstraction for the time being.  It

  292.      will actually be fairly easy to eliminate the extra copy in the

  293.      future */

  294. 

  295.   memcpy(os->body_data+os->body_fill,op->packet,op->bytes);

  296.   os->body_fill+=op->bytes;

  297. 

  298.   /* Store lacing vals for this packet */

  299.   for(i=0;i<lacing_vals-1;i++){

  300.     os->lacing_vals[os->lacing_fill+i]=255;

  301.     os->granule_vals[os->lacing_fill+i]=os->granulepos;

  302.   }

  303.   os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;

  304.   os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;

  305. 

  306.   /* flag the first segment as the beginning of the packet */

  307.   os->lacing_vals[os->lacing_fill]|= 0x100;

  308. 

  309.   os->lacing_fill+=lacing_vals;

  310. 

  311.   /* for the sake of completeness */

  312.   os->packetno++;

  313. 

  314.   if(op->e_o_s)os->e_o_s=1;

  315. 

  316.   return(0);

  317. }

  318. 

  319. /* This will flush remaining packets into a page (returning nonzero),

  320.    even if there is not enough data to trigger a flush normally

  321.    (undersized page). If there are no packets or partial packets to

  322.    flush, ogg_stream_flush returns 0.  Note that ogg_stream_flush will

  323.    try to flush a normal sized page like ogg_stream_pageout; a call to

  324.    ogg_stream_flush does not guarantee that all packets have flushed.

  325.    Only a return value of 0 from ogg_stream_flush indicates all packet

  326.    data is flushed into pages.

  327. 

  328.    since ogg_stream_flush will flush the last page in a stream even if

  329.    it's undersized, you almost certainly want to use ogg_stream_pageout

  330.    (and *not* ogg_stream_flush) unless you specifically need to flush

  331.    an page regardless of size in the middle of a stream. */

  332. 

  333. int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){

  334.   int i;

  335.   int vals=0;

  336.   int maxvals=(os->lacing_fill>255?255:os->lacing_fill);

  337.   int bytes=0;

  338.   long acc=0;

  339.   ogg_int64_t granule_pos=-1;

  340. 

  341.   if(maxvals==0)return(0);

  342. 

  343.   /* construct a page */

  344.   /* decide how many segments to include */

  345. 

  346.   /* If this is the initial header case, the first page must only include

  347.      the initial header packet */

  348.   if(os->b_o_s==0){  /* 'initial header page' case */

  349.     granule_pos=0;

  350.     for(vals=0;vals<maxvals;vals++){

  351.       if((os->lacing_vals[vals]&0x0ff)<255){

  352. 	vals++;

  353. 	break;

  354.       }

  355.     }

  356.   }else{

  357.     for(vals=0;vals<maxvals;vals++){

  358.       if(acc>4096)break;

  359.       acc+=os->lacing_vals[vals]&0x0ff;

  360.       if((os->lacing_vals[vals]&0xff)<255)

  361.         granule_pos=os->granule_vals[vals];

  362.     }

  363.   }

  364. 

  365.   /* construct the header in temp storage */

  366.   memcpy(os->header,"OggS",4);

  367. 

  368.   /* stream structure version */

  369.   os->header[4]=0x00;

  370. 

  371.   /* continued packet flag? */

  372.   os->header[5]=0x00;

  373.   if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;

  374.   /* first page flag? */

  375.   if(os->b_o_s==0)os->header[5]|=0x02;

  376.   /* last page flag? */

  377.   if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;

  378.   os->b_o_s=1;

  379. 

  380.   /* 64 bits of PCM position */

  381.   for(i=6;i<14;i++){

  382.     os->header[i]=(unsigned char)(granule_pos&0xff);

  383.     granule_pos>>=8;

  384.   }

  385. 

  386.   /* 32 bits of stream serial number */

  387.   {

  388.     long serialno=os->serialno;

  389.     for(i=14;i<18;i++){

  390.       os->header[i]=(unsigned char)(serialno&0xff);

  391.       serialno>>=8;

  392.     }

  393.   }

  394. 

  395.   /* 32 bits of page counter (we have both counter and page header

  396.      because this val can roll over) */

  397.   if(os->pageno==-1)os->pageno=0; /* because someone called

  398. 				     stream_reset; this would be a

  399. 				     strange thing to do in an

  400. 				     encode stream, but it has

  401. 				     plausible uses */

  402.   {

  403.     long pageno=os->pageno++;

  404.     for(i=18;i<22;i++){

  405.       os->header[i]=(unsigned char)(pageno&0xff);

  406.       pageno>>=8;

  407.     }

  408.   }

  409. 

  410.   /* zero for computation; filled in later */

  411.   os->header[22]=0;

  412.   os->header[23]=0;

  413.   os->header[24]=0;

  414.   os->header[25]=0;

  415. 

  416.   /* segment table */

  417.   os->header[26]=(unsigned char)(vals&0xff);

  418.   for(i=0;i<vals;i++)

  419.     bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);

  420. 

  421.   /* set pointers in the ogg_page struct */

  422.   og->header=os->header;

  423.   og->header_len=os->header_fill=vals+27;

  424.   og->body=os->body_data+os->body_returned;

  425.   og->body_len=bytes;

  426. 

  427.   /* advance the lacing data and set the body_returned pointer */

  428. 

  429.   os->lacing_fill-=vals;

  430.   memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));

  431.   memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));

  432.   os->body_returned+=bytes;

  433. 

  434.   /* calculate the checksum */

  435. 

  436.   ogg_page_checksum_set(og);

  437. 

  438.   /* done */

  439.   return(1);

  440. }

  441. 

  442. 

  443. /* This constructs pages from buffered packet segments.  The pointers

  444. returned are to static buffers; do not free. The returned buffers are

  445. good only until the next call (using the same ogg_stream_state) */

  446. 

  447. int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){

  448. 

  449.   if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */

  450.      os->body_fill-os->body_returned > 4096 ||/* 'page nominal size' case */

  451.      os->lacing_fill>=255 ||                  /* 'segment table full' case */

  452.      (os->lacing_fill&&!os->b_o_s)){          /* 'initial header page' case */

  453. 

  454.     return(ogg_stream_flush(os,og));

  455.   }

  456. 

  457.   /* not enough data to construct a page and not end of stream */

  458.   return(0);

  459. }

  460. 

  461. int ogg_stream_eos(ogg_stream_state *os){

  462.   return os->e_o_s;

  463. }

  464. 

  465. /* DECODING PRIMITIVES: packet streaming layer **********************/

  466. 

  467. /* This has two layers to place more of the multi-serialno and paging

  468.    control in the application's hands.  First, we expose a data buffer

  469.    using ogg_sync_buffer().  The app either copies into the

  470.    buffer, or passes it directly to read(), etc.  We then call

  471.    ogg_sync_wrote() to tell how many bytes we just added.

  472. 

  473.    Pages are returned (pointers into the buffer in ogg_sync_state)

  474.    by ogg_sync_pageout().  The page is then submitted to

  475.    ogg_stream_pagein() along with the appropriate

  476.    ogg_stream_state* (ie, matching serialno).  We then get raw

  477.    packets out calling ogg_stream_packetout() with a

  478.    ogg_stream_state. */

  479. 

  480. /* initialize the struct to a known state */

  481. int ogg_sync_init(ogg_sync_state *oy){

  482.   if(oy){

  483.     memset(oy,0,sizeof(*oy));

  484.   }

  485.   return(0);

  486. }

  487. 

  488. /* clear non-flat storage within */

  489. int ogg_sync_clear(ogg_sync_state *oy){

  490.   if(oy){

  491.     if(oy->data)_ogg_free(oy->data);

  492.     ogg_sync_init(oy);

  493.   }

  494.   return(0);

  495. }

  496. 

  497. int ogg_sync_destroy(ogg_sync_state *oy){

  498.   if(oy){

  499.     ogg_sync_clear(oy);

  500.     _ogg_free(oy);

  501.   }

  502.   return(0);

  503. }

  504. 

  505. char *ogg_sync_buffer(ogg_sync_state *oy, long size){

  506. 

  507.   /* first, clear out any space that has been previously returned */

  508.   if(oy->returned){

  509.     oy->fill-=oy->returned;

  510.     if(oy->fill>0)

  511.       memmove(oy->data,oy->data+oy->returned,oy->fill);

  512.     oy->returned=0;

  513.   }

  514. 

  515.   if(size>oy->storage-oy->fill){

  516.     /* We need to extend the internal buffer */

  517.     long newsize=size+oy->fill+4096; /* an extra page to be nice */

  518. 

  519.     if(oy->data)

  520.       oy->data=(unsigned char*) _ogg_realloc(oy->data,newsize);

  521.     else

  522.       oy->data=(unsigned char*) _ogg_malloc(newsize);

  523.     oy->storage=newsize;

  524.   }

  525. 

  526.   /* expose a segment at least as large as requested at the fill mark */

  527.   return((char *)oy->data+oy->fill);

  528. }

  529. 

  530. int ogg_sync_wrote(ogg_sync_state *oy, long bytes){

  531.   if(oy->fill+bytes>oy->storage)return(-1);

  532.   oy->fill+=bytes;

  533.   return(0);

  534. }

  535. 

  536. /* sync the stream.  This is meant to be useful for finding page

  537.    boundaries.

  538. 

  539.    return values for this:

  540.   -n) skipped n bytes

  541.    0) page not ready; more data (no bytes skipped)

  542.    n) page synced at current location; page length n bytes

  543. 

  544. */

  545. 

  546. long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){

  547.   unsigned char *page=oy->data+oy->returned;

  548.   unsigned char *next;

  549.   long bytes=oy->fill-oy->returned;

  550. 

  551.   if(oy->headerbytes==0){

  552.     int headerbytes,i;

  553.     if(bytes<27)return(0); /* not enough for a header */

  554. 

  555.     /* verify capture pattern */

  556.     if(memcmp(page,"OggS",4))goto sync_fail;

  557. 

  558.     headerbytes=page[26]+27;

  559.     if(bytes<headerbytes)return(0); /* not enough for header + seg table */

  560. 

  561.     /* count up body length in the segment table */

  562. 

  563.     for(i=0;i<page[26];i++)

  564.       oy->bodybytes+=page[27+i];

  565.     oy->headerbytes=headerbytes;

  566.   }

  567. 

  568.   if(oy->bodybytes+oy->headerbytes>bytes)return(0);

  569. 

  570.   /* The whole test page is buffered.  Verify the checksum */

  571.   {

  572.     /* Grab the checksum bytes, set the header field to zero */

  573.     char chksum[4];

  574.     ogg_page log;

  575. 

  576.     memcpy(chksum,page+22,4);

  577.     memset(page+22,0,4);

  578. 

  579.     /* set up a temp page struct and recompute the checksum */

  580.     log.header=page;

  581.     log.header_len=oy->headerbytes;

  582.     log.body=page+oy->headerbytes;

  583.     log.body_len=oy->bodybytes;

  584.     ogg_page_checksum_set(&log);

  585. 

  586.     /* Compare */

  587.     if(memcmp(chksum,page+22,4)){

  588.       /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page

  589. 	 at all) */

  590.       /* replace the computed checksum with the one actually read in */

  591.       memcpy(page+22,chksum,4);

  592. 

  593.       /* Bad checksum. Lose sync */

  594.       goto sync_fail;

  595.     }

  596.   }

  597. 

  598.   /* yes, have a whole page all ready to go */

  599.   {

  600.     unsigned char *page=oy->data+oy->returned;

  601.     long bytes;

  602. 

  603.     if(og){

  604.       og->header=page;

  605.       og->header_len=oy->headerbytes;

  606.       og->body=page+oy->headerbytes;

  607.       og->body_len=oy->bodybytes;

  608.     }

  609. 

  610.     oy->unsynced=0;

  611.     oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);

  612.     oy->headerbytes=0;

  613.     oy->bodybytes=0;

  614.     return(bytes);

  615.   }

  616. 

  617.  sync_fail:

  618. 

  619.   oy->headerbytes=0;

  620.   oy->bodybytes=0;

  621. 

  622.   /* search for possible capture */

  623.   next=(unsigned char*)memchr(page+1,'O',bytes-1);

  624.   if(!next)

  625.     next=oy->data+oy->fill;

  626. 

  627.   oy->returned=next-oy->data;

  628.   return(-(next-page));

  629. }

  630. 

  631. /* sync the stream and get a page.  Keep trying until we find a page.

  632.    Supress 'sync errors' after reporting the first.

  633. 

  634.    return values:

  635.    -1) recapture (hole in data)

  636.     0) need more data

  637.     1) page returned

  638. 

  639.    Returns pointers into buffered data; invalidated by next call to

  640.    _stream, _clear, _init, or _buffer */

  641. 

  642. int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){

  643. 

  644.   /* all we need to do is verify a page at the head of the stream

  645.      buffer.  If it doesn't verify, we look for the next potential

  646.      frame */

  647. 

  648.   for(;;){

  649.     long ret=ogg_sync_pageseek(oy,og);

  650.     if(ret>0){

  651.       /* have a page */

  652.       return(1);

  653.     }

  654.     if(ret==0){

  655.       /* need more data */

  656.       return(0);

  657.     }

  658. 

  659.     /* head did not start a synced page... skipped some bytes */

  660.     if(!oy->unsynced){

  661.       oy->unsynced=1;

  662.       return(-1);

  663.     }

  664. 

  665.     /* loop. keep looking */

  666. 

  667.   }

  668. }

  669. 

  670. /* add the incoming page to the stream state; we decompose the page

  671.    into packet segments here as well. */

  672. 

  673. int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){

  674.   unsigned char *header=og->header;

  675.   unsigned char *body=og->body;

  676.   long           bodysize=og->body_len;

  677.   int            segptr=0;

  678. 

  679.   int version=ogg_page_version(og);

  680.   int continued=ogg_page_continued(og);

  681.   int bos=ogg_page_bos(og);

  682.   int eos=ogg_page_eos(og);

  683.   ogg_int64_t granulepos=ogg_page_granulepos(og);

  684.   int serialno=ogg_page_serialno(og);

  685.   long pageno=ogg_page_pageno(og);

  686.   int segments=header[26];

  687. 

  688.   /* clean up 'returned data' */

  689.   {

  690.     long lr=os->lacing_returned;

  691.     long br=os->body_returned;

  692. 

  693.     /* body data */

  694.     if(br){

  695.       os->body_fill-=br;

  696.       if(os->body_fill)

  697. 	memmove(os->body_data,os->body_data+br,os->body_fill);

  698.       os->body_returned=0;

  699.     }

  700. 

  701.     if(lr){

  702.       /* segment table */

  703.       if(os->lacing_fill-lr){

  704. 	memmove(os->lacing_vals,os->lacing_vals+lr,

  705. 		(os->lacing_fill-lr)*sizeof(*os->lacing_vals));

  706. 	memmove(os->granule_vals,os->granule_vals+lr,

  707. 		(os->lacing_fill-lr)*sizeof(*os->granule_vals));

  708.       }

  709.       os->lacing_fill-=lr;

  710.       os->lacing_packet-=lr;

  711.       os->lacing_returned=0;

  712.     }

  713.   }

  714. 

  715.   /* check the serial number */

  716.   if(serialno!=os->serialno)return(-1);

  717.   if(version>0)return(-1);

  718. 

  719.   _os_lacing_expand(os,segments+1);

  720. 

  721.   /* are we in sequence? */

  722.   if(pageno!=os->pageno){

  723.     int i;

  724. 

  725.     /* unroll previous partial packet (if any) */

  726.     for(i=os->lacing_packet;i<os->lacing_fill;i++)

  727.       os->body_fill-=os->lacing_vals[i]&0xff;

  728.     os->lacing_fill=os->lacing_packet;

  729. 

  730.     /* make a note of dropped data in segment table */

  731.     if(os->pageno!=-1){

  732.       os->lacing_vals[os->lacing_fill++]=0x400;

  733.       os->lacing_packet++;

  734.     }

  735.   }

  736. 

  737.   /* are we a 'continued packet' page?  If so, we may need to skip

  738.      some segments */

  739.   if(continued){

  740.     if(os->lacing_fill<1 ||

  741.        os->lacing_vals[os->lacing_fill-1]==0x400){

  742.       bos=0;

  743.       for(;segptr<segments;segptr++){

  744. 	int val=header[27+segptr];

  745. 	body+=val;

  746. 	bodysize-=val;

  747. 	if(val<255){

  748. 	  segptr++;

  749. 	  break;

  750. 	}

  751.       }

  752.     }

  753.   }

  754. 

  755.   if(bodysize){

  756.     _os_body_expand(os,bodysize);

  757.     memcpy(os->body_data+os->body_fill,body,bodysize);

  758.     os->body_fill+=bodysize;

  759.   }

  760. 

  761.   {

  762.     int saved=-1;

  763.     while(segptr<segments){

  764.       int val=header[27+segptr];

  765.       os->lacing_vals[os->lacing_fill]=val;

  766.       os->granule_vals[os->lacing_fill]=-1;

  767. 

  768.       if(bos){

  769. 	os->lacing_vals[os->lacing_fill]|=0x100;

  770. 	bos=0;

  771.       }

  772. 

  773.       if(val<255)saved=os->lacing_fill;

  774. 

  775.       os->lacing_fill++;

  776.       segptr++;

  777. 

  778.       if(val<255)os->lacing_packet=os->lacing_fill;

  779.     }

  780. 

  781.     /* set the granulepos on the last granuleval of the last full packet */

  782.     if(saved!=-1){

  783.       os->granule_vals[saved]=granulepos;

  784.     }

  785. 

  786.   }

  787. 

  788.   if(eos){

  789.     os->e_o_s=1;

  790.     if(os->lacing_fill>0)

  791.       os->lacing_vals[os->lacing_fill-1]|=0x200;

  792.   }

  793. 

  794.   os->pageno=pageno+1;

  795. 

  796.   return(0);

  797. }

  798. 

  799. /* clear things to an initial state.  Good to call, eg, before seeking */

  800. int ogg_sync_reset(ogg_sync_state *oy){

  801.   oy->fill=0;

  802.   oy->returned=0;

  803.   oy->unsynced=0;

  804.   oy->headerbytes=0;

  805.   oy->bodybytes=0;

  806.   return(0);

  807. }

  808. 

  809. int ogg_stream_reset(ogg_stream_state *os){

  810.   os->body_fill=0;

  811.   os->body_returned=0;

  812. 

  813.   os->lacing_fill=0;

  814.   os->lacing_packet=0;

  815.   os->lacing_returned=0;

  816. 

  817.   os->header_fill=0;

  818. 

  819.   os->e_o_s=0;

  820.   os->b_o_s=0;

  821.   os->pageno=-1;

  822.   os->packetno=0;

  823.   os->granulepos=0;

  824. 

  825.   return(0);

  826. }

  827. 

  828. int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){

  829.   ogg_stream_reset(os);

  830.   os->serialno=serialno;

  831.   return(0);

  832. }

  833. 

  834. static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){

  835. 

  836.   /* The last part of decode. We have the stream broken into packet

  837.      segments.  Now we need to group them into packets (or return the

  838.      out of sync markers) */

  839. 

  840.   int ptr=os->lacing_returned;

  841. 

  842.   if(os->lacing_packet<=ptr)return(0);

  843. 

  844.   if(os->lacing_vals[ptr]&0x400){

  845.     /* we need to tell the codec there's a gap; it might need to

  846.        handle previous packet dependencies. */

  847.     os->lacing_returned++;

  848.     os->packetno++;

  849.     return(-1);

  850.   }

  851. 

  852.   if(!op && !adv)return(1); /* just using peek as an inexpensive way

  853.                                to ask if there's a whole packet

  854.                                waiting */

  855. 

  856.   /* Gather the whole packet. We'll have no holes or a partial packet */

  857.   {

  858.     int size=os->lacing_vals[ptr]&0xff;

  859.     int bytes=size;

  860.     int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */

  861.     int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */

  862. 

  863.     while(size==255){

  864.       int val=os->lacing_vals[++ptr];

  865.       size=val&0xff;

  866.       if(val&0x200)eos=0x200;

  867.       bytes+=size;

  868.     }

  869. 

  870.     if(op){

  871.       op->e_o_s=eos;

  872.       op->b_o_s=bos;

  873.       op->packet=os->body_data+os->body_returned;

  874.       op->packetno=os->packetno;

  875.       op->granulepos=os->granule_vals[ptr];

  876.       op->bytes=bytes;

  877.     }

  878. 

  879.     if(adv){

  880.       os->body_returned+=bytes;

  881.       os->lacing_returned=ptr+1;

  882.       os->packetno++;

  883.     }

  884.   }

  885.   return(1);

  886. }

  887. 

  888. int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){

  889.   return _packetout(os,op,1);

  890. }

  891. 

  892. int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){

  893.   return _packetout(os,op,0);

  894. }

  895. 

  896. void ogg_packet_clear(ogg_packet *op) {

  897.   _ogg_free(op->packet);

  898.   memset(op, 0, sizeof(*op));

  899. }

  900. 

  901. #ifdef _V_SELFTEST

  902. #include <stdio.h>

  903. 

  904. ogg_stream_state os_en, os_de;

  905. ogg_sync_state oy;

  906. 

  907. void checkpacket(ogg_packet *op,int len, int no, int pos){

  908.   long j;

  909.   static int sequence=0;

  910.   static int lastno=0;

  911. 

  912.   if(op->bytes!=len){

  913.     fprintf(stderr,"incorrect packet length!\n");

  914.     exit(1);

  915.   }

  916.   if(op->granulepos!=pos){

  917.     fprintf(stderr,"incorrect packet position!\n");

  918.     exit(1);

  919.   }

  920. 

  921.   /* packet number just follows sequence/gap; adjust the input number

  922.      for that */

  923.   if(no==0){

  924.     sequence=0;

  925.   }else{

  926.     sequence++;

  927.     if(no>lastno+1)

  928.       sequence++;

  929.   }

  930.   lastno=no;

  931.   if(op->packetno!=sequence){

  932.     fprintf(stderr,"incorrect packet sequence %ld != %d\n",

  933. 	    (long)(op->packetno),sequence);

  934.     exit(1);

  935.   }

  936. 

  937.   /* Test data */

  938.   for(j=0;j<op->bytes;j++)

  939.     if(op->packet[j]!=((j+no)&0xff)){

  940.       fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",

  941. 	      j,op->packet[j],(j+no)&0xff);

  942.       exit(1);

  943.     }

  944. }

  945. 

  946. void check_page(unsigned char *data,const int *header,ogg_page *og){

  947.   long j;

  948.   /* Test data */

  949.   for(j=0;j<og->body_len;j++)

  950.     if(og->body[j]!=data[j]){

  951.       fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",

  952. 	      j,data[j],og->body[j]);

  953.       exit(1);

  954.     }

  955. 

  956.   /* Test header */

  957.   for(j=0;j<og->header_len;j++){

  958.     if(og->header[j]!=header[j]){

  959.       fprintf(stderr,"header content mismatch at pos %ld:\n",j);

  960.       for(j=0;j<header[26]+27;j++)

  961. 	fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);

  962.       fprintf(stderr,"\n");

  963.       exit(1);

  964.     }

  965.   }

  966.   if(og->header_len!=header[26]+27){

  967.     fprintf(stderr,"header length incorrect! (%ld!=%d)\n",

  968. 	    og->header_len,header[26]+27);

  969.     exit(1);

  970.   }

  971. }

  972. 

  973. void print_header(ogg_page *og){

  974.   int j;

  975.   fprintf(stderr,"\nHEADER:\n");

  976.   fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %x\n",

  977. 	  og->header[0],og->header[1],og->header[2],og->header[3],

  978. 	  (int)og->header[4],(int)og->header[5]);

  979. 

  980.   fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ld\n",

  981. 	  (og->header[9]<<24)|(og->header[8]<<16)|

  982. 	  (og->header[7]<<8)|og->header[6],

  983. 	  (og->header[17]<<24)|(og->header[16]<<16)|

  984. 	  (og->header[15]<<8)|og->header[14],

  985. 	  ((long)(og->header[21])<<24)|(og->header[20]<<16)|

  986. 	  (og->header[19]<<8)|og->header[18]);

  987. 

  988.   fprintf(stderr,"  checksum: %02x:%02x:%02x:%02x\n  segments: %d (",

  989. 	  (int)og->header[22],(int)og->header[23],

  990. 	  (int)og->header[24],(int)og->header[25],

  991. 	  (int)og->header[26]);

  992. 

  993.   for(j=27;j<og->header_len;j++)

  994.     fprintf(stderr,"%d ",(int)og->header[j]);

  995.   fprintf(stderr,")\n\n");

  996. }

  997. 

  998. void copy_page(ogg_page *og){

  999.   unsigned char *temp=_ogg_malloc(og->header_len);

  1000.   memcpy(temp,og->header,og->header_len);

  1001.   og->header=temp;

  1002. 

  1003.   temp=_ogg_malloc(og->body_len);

  1004.   memcpy(temp,og->body,og->body_len);

  1005.   og->body=temp;

  1006. }

  1007. 

  1008. void free_page(ogg_page *og){

  1009.   _ogg_free (og->header);

  1010.   _ogg_free (og->body);

  1011. }

  1012. 

  1013. void error(void){

  1014.   fprintf(stderr,"error!\n");

  1015.   exit(1);

  1016. }

  1017. 

  1018. /* 17 only */

  1019. const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,

  1020. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1021. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1022. 		       0x15,0xed,0xec,0x91,

  1023. 		       1,

  1024. 		       17};

  1025. 

  1026. /* 17, 254, 255, 256, 500, 510, 600 byte, pad */

  1027. const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1028. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1029. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1030. 		       0x59,0x10,0x6c,0x2c,

  1031. 		       1,

  1032. 		       17};

  1033. const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,

  1034. 		       0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,

  1035. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1036. 		       0x89,0x33,0x85,0xce,

  1037. 		       13,

  1038. 		       254,255,0,255,1,255,245,255,255,0,

  1039. 		       255,255,90};

  1040. 

  1041. /* nil packets; beginning,middle,end */

  1042. const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1043. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1044. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1045. 		       0xff,0x7b,0x23,0x17,

  1046. 		       1,

  1047. 		       0};

  1048. const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,

  1049. 		       0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,

  1050. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1051. 		       0x5c,0x3f,0x66,0xcb,

  1052. 		       17,

  1053. 		       17,254,255,0,0,255,1,0,255,245,255,255,0,

  1054. 		       255,255,90,0};

  1055. 

  1056. /* large initial packet */

  1057. const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1058. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1059. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1060. 		       0x01,0x27,0x31,0xaa,

  1061. 		       18,

  1062. 		       255,255,255,255,255,255,255,255,

  1063. 		       255,255,255,255,255,255,255,255,255,10};

  1064. 

  1065. const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,

  1066. 		       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,

  1067. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1068. 		       0x7f,0x4e,0x8a,0xd2,

  1069. 		       4,

  1070. 		       255,4,255,0};

  1071. 

  1072. 

  1073. /* continuing packet test */

  1074. const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1075. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1076. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1077. 		       0xff,0x7b,0x23,0x17,

  1078. 		       1,

  1079. 		       0};

  1080. 

  1081. const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,

  1082. 		       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

  1083. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1084. 		       0x54,0x05,0x51,0xc8,

  1085. 		       17,

  1086. 		       255,255,255,255,255,255,255,255,

  1087. 		       255,255,255,255,255,255,255,255,255};

  1088. 

  1089. const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,

  1090. 		       0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,

  1091. 		       0x01,0x02,0x03,0x04,2,0,0,0,

  1092. 		       0xc8,0xc3,0xcb,0xed,

  1093. 		       5,

  1094. 		       10,255,4,255,0};

  1095. 

  1096. 

  1097. /* page with the 255 segment limit */

  1098. const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1099. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1100. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1101. 		       0xff,0x7b,0x23,0x17,

  1102. 		       1,

  1103. 		       0};

  1104. 

  1105. const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,

  1106. 		       0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,

  1107. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1108. 		       0xed,0x2a,0x2e,0xa7,

  1109. 		       255,

  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,10,

  1134. 		       10,10,10,10,10,10,10,10,

  1135. 		       10,10,10,10,10,10,10,10,

  1136. 		       10,10,10,10,10,10,10,10,

  1137. 		       10,10,10,10,10,10,10,10,

  1138. 		       10,10,10,10,10,10,10,10,

  1139. 		       10,10,10,10,10,10,10,10,

  1140. 		       10,10,10,10,10,10,10,10,

  1141. 		       10,10,10,10,10,10,10};

  1142. 

  1143. const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,

  1144. 		       0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,

  1145. 		       0x01,0x02,0x03,0x04,2,0,0,0,

  1146. 		       0x6c,0x3b,0x82,0x3d,

  1147. 		       1,

  1148. 		       50};

  1149. 

  1150. 

  1151. /* packet that overspans over an entire page */

  1152. const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1153. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1154. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1155. 		       0xff,0x7b,0x23,0x17,

  1156. 		       1,

  1157. 		       0};

  1158. 

  1159. const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,

  1160. 		       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,

  1161. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1162. 		       0x3c,0xd9,0x4d,0x3f,

  1163. 		       17,

  1164. 		       100,255,255,255,255,255,255,255,255,

  1165. 		       255,255,255,255,255,255,255,255};

  1166. 

  1167. const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,

  1168. 		       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

  1169. 		       0x01,0x02,0x03,0x04,2,0,0,0,

  1170. 		       0x01,0xd2,0xe5,0xe5,

  1171. 		       17,

  1172. 		       255,255,255,255,255,255,255,255,

  1173. 		       255,255,255,255,255,255,255,255,255};

  1174. 

  1175. const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,

  1176. 		       0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,

  1177. 		       0x01,0x02,0x03,0x04,3,0,0,0,

  1178. 		       0xef,0xdd,0x88,0xde,

  1179. 		       7,

  1180. 		       255,255,75,255,4,255,0};

  1181. 

  1182. /* packet that overspans over an entire page */

  1183. const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,

  1184. 		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  1185. 		       0x01,0x02,0x03,0x04,0,0,0,0,

  1186. 		       0xff,0x7b,0x23,0x17,

  1187. 		       1,

  1188. 		       0};

  1189. 

  1190. const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,

  1191. 		       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,

  1192. 		       0x01,0x02,0x03,0x04,1,0,0,0,

  1193. 		       0x3c,0xd9,0x4d,0x3f,

  1194. 		       17,

  1195. 		       100,255,255,255,255,255,255,255,255,

  1196. 		       255,255,255,255,255,255,255,255};

  1197. 

  1198. const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,

  1199. 		       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,

  1200. 		       0x01,0x02,0x03,0x04,2,0,0,0,

  1201. 		       0xd4,0xe0,0x60,0xe5,

  1202. 		       1,0};

  1203. 

  1204. void test_pack(const int *pl, const int **headers, int byteskip,

  1205. 	       int pageskip, int packetskip){

  1206.   unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */

  1207.   long inptr=0;

  1208.   long outptr=0;

  1209.   long deptr=0;

  1210.   long depacket=0;

  1211.   long granule_pos=7,pageno=0;

  1212.   int i,j,packets,pageout=pageskip;

  1213.   int eosflag=0;

  1214.   int bosflag=0;

  1215. 

  1216.   int byteskipcount=0;

  1217. 

  1218.   ogg_stream_reset(&os_en);

  1219.   ogg_stream_reset(&os_de);

  1220.   ogg_sync_reset(&oy);

  1221. 

  1222.   for(packets=0;packets<packetskip;packets++)

  1223.     depacket+=pl[packets];

  1224. 

  1225.   for(packets=0;;packets++)if(pl[packets]==-1)break;

  1226. 

  1227.   for(i=0;i<packets;i++){

  1228.     /* construct a test packet */

  1229.     ogg_packet op;

  1230.     int len=pl[i];

  1231. 

  1232.     op.packet=data+inptr;

  1233.     op.bytes=len;

  1234.     op.e_o_s=(pl[i+1]<0?1:0);

  1235.     op.granulepos=granule_pos;

  1236. 

  1237.     granule_pos+=1024;

  1238. 

  1239.     for(j=0;j<len;j++)data[inptr++]=i+j;

  1240. 

  1241.     /* submit the test packet */

  1242.     ogg_stream_packetin(&os_en,&op);

  1243. 

  1244.     /* retrieve any finished pages */

  1245.     {

  1246.       ogg_page og;

  1247. 

  1248.       while(ogg_stream_pageout(&os_en,&og)){

  1249. 	/* We have a page.  Check it carefully */

  1250. 

  1251. 	fprintf(stderr,"%ld, ",pageno);

  1252. 

  1253. 	if(headers[pageno]==NULL){

  1254. 	  fprintf(stderr,"coded too many pages!\n");

  1255. 	  exit(1);

  1256. 	}

  1257. 

  1258. 	check_page(data+outptr,headers[pageno],&og);

  1259. 

  1260. 	outptr+=og.body_len;

  1261. 	pageno++;

  1262. 	if(pageskip){

  1263. 	  bosflag=1;

  1264. 	  pageskip--;

  1265. 	  deptr+=og.body_len;

  1266. 	}

  1267. 

  1268. 	/* have a complete page; submit it to sync/decode */

  1269. 

  1270. 	{

  1271. 	  ogg_page og_de;

  1272. 	  ogg_packet op_de,op_de2;

  1273. 	  char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);

  1274. 	  char *next=buf;

  1275. 	  byteskipcount+=og.header_len;

  1276. 	  if(byteskipcount>byteskip){

  1277. 	    memcpy(next,og.header,byteskipcount-byteskip);

  1278. 	    next+=byteskipcount-byteskip;

  1279. 	    byteskipcount=byteskip;

  1280. 	  }

  1281. 

  1282. 	  byteskipcount+=og.body_len;

  1283. 	  if(byteskipcount>byteskip){

  1284. 	    memcpy(next,og.body,byteskipcount-byteskip);

  1285. 	    next+=byteskipcount-byteskip;

  1286. 	    byteskipcount=byteskip;

  1287. 	  }

  1288. 

  1289. 	  ogg_sync_wrote(&oy,next-buf);

  1290. 

  1291. 	  while(1){

  1292. 	    int ret=ogg_sync_pageout(&oy,&og_de);

  1293. 	    if(ret==0)break;

  1294. 	    if(ret<0)continue;

  1295. 	    /* got a page.  Happy happy.  Verify that it's good. */

  1296. 

  1297. 	    fprintf(stderr,"(%ld), ",pageout);

  1298. 

  1299. 	    check_page(data+deptr,headers[pageout],&og_de);

  1300. 	    deptr+=og_de.body_len;

  1301. 	    pageout++;

  1302. 

  1303. 	    /* submit it to deconstitution */

  1304. 	    ogg_stream_pagein(&os_de,&og_de);

  1305. 

  1306. 	    /* packets out? */

  1307. 	    while(ogg_stream_packetpeek(&os_de,&op_de2)>0){

  1308. 	      ogg_stream_packetpeek(&os_de,NULL);

  1309. 	      ogg_stream_packetout(&os_de,&op_de); /* just catching them all */

  1310. 

  1311. 	      /* verify peek and out match */

  1312. 	      if(memcmp(&op_de,&op_de2,sizeof(op_de))){

  1313. 		fprintf(stderr,"packetout != packetpeek! pos=%ld\n",

  1314. 			depacket);

  1315. 		exit(1);

  1316. 	      }

  1317. 

  1318. 	      /* verify the packet! */

  1319. 	      /* check data */

  1320. 	      if(memcmp(data+depacket,op_de.packet,op_de.bytes)){

  1321. 		fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",

  1322. 			depacket);

  1323. 		exit(1);

  1324. 	      }

  1325. 	      /* check bos flag */

  1326. 	      if(bosflag==0 && op_de.b_o_s==0){

  1327. 		fprintf(stderr,"b_o_s flag not set on packet!\n");

  1328. 		exit(1);

  1329. 	      }

  1330. 	      if(bosflag && op_de.b_o_s){

  1331. 		fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");

  1332. 		exit(1);

  1333. 	      }

  1334. 	      bosflag=1;

  1335. 	      depacket+=op_de.bytes;

  1336. 

  1337. 	      /* check eos flag */

  1338. 	      if(eosflag){

  1339. 		fprintf(stderr,"Multiple decoded packets with eos flag!\n");

  1340. 		exit(1);

  1341. 	      }

  1342. 

  1343. 	      if(op_de.e_o_s)eosflag=1;

  1344. 

  1345. 	      /* check granulepos flag */

  1346. 	      if(op_de.granulepos!=-1){

  1347. 		fprintf(stderr," granule:%ld ",(long)op_de.granulepos);

  1348. 	      }

  1349. 	    }

  1350. 	  }

  1351. 	}

  1352.       }

  1353.     }

  1354.   }

  1355.   _ogg_free(data);

  1356.   if(headers[pageno]!=NULL){

  1357.     fprintf(stderr,"did not write last page!\n");

  1358.     exit(1);

  1359.   }

  1360.   if(headers[pageout]!=NULL){

  1361.     fprintf(stderr,"did not decode last page!\n");

  1362.     exit(1);

  1363.   }

  1364.   if(inptr!=outptr){

  1365.     fprintf(stderr,"encoded page data incomplete!\n");

  1366.     exit(1);

  1367.   }

  1368.   if(inptr!=deptr){

  1369.     fprintf(stderr,"decoded page data incomplete!\n");

  1370.     exit(1);

  1371.   }

  1372.   if(inptr!=depacket){

  1373.     fprintf(stderr,"decoded packet data incomplete!\n");

  1374.     exit(1);

  1375.   }

  1376.   if(!eosflag){

  1377.     fprintf(stderr,"Never got a packet with EOS set!\n");

  1378.     exit(1);

  1379.   }

  1380.   fprintf(stderr,"ok.\n");

  1381. }

  1382. 

  1383. int main(void){

  1384. 

  1385.   ogg_stream_init(&os_en,0x04030201);

  1386.   ogg_stream_init(&os_de,0x04030201);

  1387.   ogg_sync_init(&oy);

  1388. 

  1389.   /* Exercise each code path in the framing code.  Also verify that

  1390.      the checksums are working.  */

  1391. 

  1392.   {

  1393.     /* 17 only */

  1394.     const int packets[]={17, -1};

  1395.     const int *headret[]={head1_0,NULL};

  1396. 

  1397.     fprintf(stderr,"testing single page encoding... ");

  1398.     test_pack(packets,headret,0,0,0);

  1399.   }

  1400. 

  1401.   {

  1402.     /* 17, 254, 255, 256, 500, 510, 600 byte, pad */

  1403.     const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};

  1404.     const int *headret[]={head1_1,head2_1,NULL};

  1405. 

  1406.     fprintf(stderr,"testing basic page encoding... ");

  1407.     test_pack(packets,headret,0,0,0);

  1408.   }

  1409. 

  1410.   {

  1411.     /* nil packets; beginning,middle,end */

  1412.     const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};

  1413.     const int *headret[]={head1_2,head2_2,NULL};

  1414. 

  1415.     fprintf(stderr,"testing basic nil packets... ");

  1416.     test_pack(packets,headret,0,0,0);

  1417.   }

  1418. 

  1419.   {

  1420.     /* large initial packet */

  1421.     const int packets[]={4345,259,255,-1};

  1422.     const int *headret[]={head1_3,head2_3,NULL};

  1423. 

  1424.     fprintf(stderr,"testing initial-packet lacing > 4k... ");

  1425.     test_pack(packets,headret,0,0,0);

  1426.   }

  1427. 

  1428.   {

  1429.     /* continuing packet test */

  1430.     const int packets[]={0,4345,259,255,-1};

  1431.     const int *headret[]={head1_4,head2_4,head3_4,NULL};

  1432. 

  1433.     fprintf(stderr,"testing single packet page span... ");

  1434.     test_pack(packets,headret,0,0,0);

  1435.   }

  1436. 

  1437.   /* page with the 255 segment limit */

  1438.   {

  1439. 

  1440.     const int packets[]={0,10,10,10,10,10,10,10,10,

  1441. 		   10,10,10,10,10,10,10,10,

  1442. 		   10,10,10,10,10,10,10,10,

  1443. 		   10,10,10,10,10,10,10,10,

  1444. 		   10,10,10,10,10,10,10,10,

  1445. 		   10,10,10,10,10,10,10,10,

  1446. 		   10,10,10,10,10,10,10,10,

  1447. 		   10,10,10,10,10,10,10,10,

  1448. 		   10,10,10,10,10,10,10,10,

  1449. 		   10,10,10,10,10,10,10,10,

  1450. 		   10,10,10,10,10,10,10,10,

  1451. 		   10,10,10,10,10,10,10,10,

  1452. 		   10,10,10,10,10,10,10,10,

  1453. 		   10,10,10,10,10,10,10,10,

  1454. 		   10,10,10,10,10,10,10,10,

  1455. 		   10,10,10,10,10,10,10,10,

  1456. 		   10,10,10,10,10,10,10,10,

  1457. 		   10,10,10,10,10,10,10,10,

  1458. 		   10,10,10,10,10,10,10,10,

  1459. 		   10,10,10,10,10,10,10,10,

  1460. 		   10,10,10,10,10,10,10,10,

  1461. 		   10,10,10,10,10,10,10,10,

  1462. 		   10,10,10,10,10,10,10,10,

  1463. 		   10,10,10,10,10,10,10,10,

  1464. 		   10,10,10,10,10,10,10,10,

  1465. 		   10,10,10,10,10,10,10,10,

  1466. 		   10,10,10,10,10,10,10,10,

  1467. 		   10,10,10,10,10,10,10,10,

  1468. 		   10,10,10,10,10,10,10,10,

  1469. 		   10,10,10,10,10,10,10,10,

  1470. 		   10,10,10,10,10,10,10,10,

  1471. 		   10,10,10,10,10,10,10,50,-1};

  1472.     const int *headret[]={head1_5,head2_5,head3_5,NULL};

  1473. 

  1474.     fprintf(stderr,"testing max packet segments... ");

  1475.     test_pack(packets,headret,0,0,0);

  1476.   }

  1477. 

  1478.   {

  1479.     /* packet that overspans over an entire page */

  1480.     const int packets[]={0,100,9000,259,255,-1};

  1481.     const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};

  1482. 

  1483.     fprintf(stderr,"testing very large packets... ");

  1484.     test_pack(packets,headret,0,0,0);

  1485.   }

  1486. 

  1487.   {

  1488.     /* test for the libogg 1.1.1 resync in large continuation bug

  1489.        found by Josh Coalson)  */

  1490.     const int packets[]={0,100,9000,259,255,-1};

  1491.     const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};

  1492. 

  1493.     fprintf(stderr,"testing continuation resync in very large packets... ");

  1494.     test_pack(packets,headret,100,2,3);

  1495.   }

  1496. 

  1497.   {

  1498.     /* term only page.  why not? */

  1499.     const int packets[]={0,100,4080,-1};

  1500.     const int *headret[]={head1_7,head2_7,head3_7,NULL};

  1501. 

  1502.     fprintf(stderr,"testing zero data page (1 nil packet)... ");

  1503.     test_pack(packets,headret,0,0,0);

  1504.   }

  1505. 

  1506. 

  1507. 

  1508.   {

  1509.     /* build a bunch of pages for testing */

  1510.     unsigned char *data=_ogg_malloc(1024*1024);

  1511.     int pl[]={0,100,4079,2956,2057,76,34,912,0,234,1000,1000,1000,300,-1};

  1512.     int inptr=0,i,j;

  1513.     ogg_page og[5];

  1514. 

  1515.     ogg_stream_reset(&os_en);

  1516. 

  1517.     for(i=0;pl[i]!=-1;i++){

  1518.       ogg_packet op;

  1519.       int len=pl[i];

  1520. 

  1521.       op.packet=data+inptr;

  1522.       op.bytes=len;

  1523.       op.e_o_s=(pl[i+1]<0?1:0);

  1524.       op.granulepos=(i+1)*1000;

  1525. 

  1526.       for(j=0;j<len;j++)data[inptr++]=i+j;

  1527.       ogg_stream_packetin(&os_en,&op);

  1528.     }

  1529. 

  1530.     _ogg_free(data);

  1531. 

  1532.     /* retrieve finished pages */

  1533.     for(i=0;i<5;i++){

  1534.       if(ogg_stream_pageout(&os_en,&og[i])==0){

  1535. 	fprintf(stderr,"Too few pages output building sync tests!\n");

  1536. 	exit(1);

  1537.       }

  1538.       copy_page(&og[i]);

  1539.     }

  1540. 

  1541.     /* Test lost pages on pagein/packetout: no rollback */

  1542.     {

  1543.       ogg_page temp;

  1544.       ogg_packet test;

  1545. 

  1546.       fprintf(stderr,"Testing loss of pages... ");

  1547. 

  1548.       ogg_sync_reset(&oy);

  1549.       ogg_stream_reset(&os_de);

  1550.       for(i=0;i<5;i++){

  1551. 	memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,

  1552. 	       og[i].header_len);

  1553. 	ogg_sync_wrote(&oy,og[i].header_len);

  1554. 	memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);

  1555. 	ogg_sync_wrote(&oy,og[i].body_len);

  1556.       }

  1557. 

  1558.       ogg_sync_pageout(&oy,&temp);

  1559.       ogg_stream_pagein(&os_de,&temp);

  1560.       ogg_sync_pageout(&oy,&temp);

  1561.       ogg_stream_pagein(&os_de,&temp);

  1562.       ogg_sync_pageout(&oy,&temp);

  1563.       /* skip */

  1564.       ogg_sync_pageout(&oy,&temp);

  1565.       ogg_stream_pagein(&os_de,&temp);

  1566. 

  1567.       /* do we get the expected results/packets? */

  1568. 

  1569.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1570.       checkpacket(&test,0,0,0);

  1571.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1572.       checkpacket(&test,100,1,-1);

  1573.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1574.       checkpacket(&test,4079,2,3000);

  1575.       if(ogg_stream_packetout(&os_de,&test)!=-1){

  1576. 	fprintf(stderr,"Error: loss of page did not return error\n");

  1577. 	exit(1);

  1578.       }

  1579.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1580.       checkpacket(&test,76,5,-1);

  1581.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1582.       checkpacket(&test,34,6,-1);

  1583.       fprintf(stderr,"ok.\n");

  1584.     }

  1585. 

  1586.     /* Test lost pages on pagein/packetout: rollback with continuation */

  1587.     {

  1588.       ogg_page temp;

  1589.       ogg_packet test;

  1590. 

  1591.       fprintf(stderr,"Testing loss of pages (rollback required)... ");

  1592. 

  1593.       ogg_sync_reset(&oy);

  1594.       ogg_stream_reset(&os_de);

  1595.       for(i=0;i<5;i++){

  1596. 	memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,

  1597. 	       og[i].header_len);

  1598. 	ogg_sync_wrote(&oy,og[i].header_len);

  1599. 	memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);

  1600. 	ogg_sync_wrote(&oy,og[i].body_len);

  1601.       }

  1602. 

  1603.       ogg_sync_pageout(&oy,&temp);

  1604.       ogg_stream_pagein(&os_de,&temp);

  1605.       ogg_sync_pageout(&oy,&temp);

  1606.       ogg_stream_pagein(&os_de,&temp);

  1607.       ogg_sync_pageout(&oy,&temp);

  1608.       ogg_stream_pagein(&os_de,&temp);

  1609.       ogg_sync_pageout(&oy,&temp);

  1610.       /* skip */

  1611.       ogg_sync_pageout(&oy,&temp);

  1612.       ogg_stream_pagein(&os_de,&temp);

  1613. 

  1614.       /* do we get the expected results/packets? */

  1615. 

  1616.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1617.       checkpacket(&test,0,0,0);

  1618.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1619.       checkpacket(&test,100,1,-1);

  1620.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1621.       checkpacket(&test,4079,2,3000);

  1622.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1623.       checkpacket(&test,2956,3,4000);

  1624.       if(ogg_stream_packetout(&os_de,&test)!=-1){

  1625. 	fprintf(stderr,"Error: loss of page did not return error\n");

  1626. 	exit(1);

  1627.       }

  1628.       if(ogg_stream_packetout(&os_de,&test)!=1)error();

  1629.       checkpacket(&test,300,13,14000);

  1630.       fprintf(stderr,"ok.\n");

  1631.     }

  1632. 

  1633.     /* the rest only test sync */

  1634.     {

  1635.       ogg_page og_de;

  1636.       /* Test fractional page inputs: incomplete capture */

  1637.       fprintf(stderr,"Testing sync on partial inputs... ");

  1638.       ogg_sync_reset(&oy);

  1639.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,

  1640. 	     3);

  1641.       ogg_sync_wrote(&oy,3);

  1642.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1643. 

  1644.       /* Test fractional page inputs: incomplete fixed header */

  1645.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,

  1646. 	     20);

  1647.       ogg_sync_wrote(&oy,20);

  1648.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1649. 

  1650.       /* Test fractional page inputs: incomplete header */

  1651.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,

  1652. 	     5);

  1653.       ogg_sync_wrote(&oy,5);

  1654.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1655. 

  1656.       /* Test fractional page inputs: incomplete body */

  1657. 

  1658.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,

  1659. 	     og[1].header_len-28);

  1660.       ogg_sync_wrote(&oy,og[1].header_len-28);

  1661.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1662. 

  1663.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);

  1664.       ogg_sync_wrote(&oy,1000);

  1665.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1666. 

  1667.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,

  1668. 	     og[1].body_len-1000);

  1669.       ogg_sync_wrote(&oy,og[1].body_len-1000);

  1670.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1671. 

  1672.       fprintf(stderr,"ok.\n");

  1673.     }

  1674. 

  1675.     /* Test fractional page inputs: page + incomplete capture */

  1676.     {

  1677.       ogg_page og_de;

  1678.       fprintf(stderr,"Testing sync on 1+partial inputs... ");

  1679.       ogg_sync_reset(&oy);

  1680. 

  1681.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,

  1682. 	     og[1].header_len);

  1683.       ogg_sync_wrote(&oy,og[1].header_len);

  1684. 

  1685.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,

  1686. 	     og[1].body_len);

  1687.       ogg_sync_wrote(&oy,og[1].body_len);

  1688. 

  1689.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,

  1690. 	     20);

  1691.       ogg_sync_wrote(&oy,20);

  1692.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1693.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1694. 

  1695.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,

  1696. 	     og[1].header_len-20);

  1697.       ogg_sync_wrote(&oy,og[1].header_len-20);

  1698.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,

  1699. 	     og[1].body_len);

  1700.       ogg_sync_wrote(&oy,og[1].body_len);

  1701.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1702. 

  1703.       fprintf(stderr,"ok.\n");

  1704.     }

  1705. 

  1706.     /* Test recapture: garbage + page */

  1707.     {

  1708.       ogg_page og_de;

  1709.       fprintf(stderr,"Testing search for capture... ");

  1710.       ogg_sync_reset(&oy);

  1711. 

  1712.       /* 'garbage' */

  1713.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,

  1714. 	     og[1].body_len);

  1715.       ogg_sync_wrote(&oy,og[1].body_len);

  1716. 

  1717.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,

  1718. 	     og[1].header_len);

  1719.       ogg_sync_wrote(&oy,og[1].header_len);

  1720. 

  1721.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,

  1722. 	     og[1].body_len);

  1723.       ogg_sync_wrote(&oy,og[1].body_len);

  1724. 

  1725.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,

  1726. 	     20);

  1727.       ogg_sync_wrote(&oy,20);

  1728.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1729.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1730.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1731. 

  1732.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,

  1733. 	     og[2].header_len-20);

  1734.       ogg_sync_wrote(&oy,og[2].header_len-20);

  1735.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,

  1736. 	     og[2].body_len);

  1737.       ogg_sync_wrote(&oy,og[2].body_len);

  1738.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1739. 

  1740.       fprintf(stderr,"ok.\n");

  1741.     }

  1742. 

  1743.     /* Test recapture: page + garbage + page */

  1744.     {

  1745.       ogg_page og_de;

  1746.       fprintf(stderr,"Testing recapture... ");

  1747.       ogg_sync_reset(&oy);

  1748. 

  1749.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,

  1750. 	     og[1].header_len);

  1751.       ogg_sync_wrote(&oy,og[1].header_len);

  1752. 

  1753.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,

  1754. 	     og[1].body_len);

  1755.       ogg_sync_wrote(&oy,og[1].body_len);

  1756. 

  1757.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,

  1758. 	     og[2].header_len);

  1759.       ogg_sync_wrote(&oy,og[2].header_len);

  1760. 

  1761.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,

  1762. 	     og[2].header_len);

  1763.       ogg_sync_wrote(&oy,og[2].header_len);

  1764. 

  1765.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1766. 

  1767.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,

  1768. 	     og[2].body_len-5);

  1769.       ogg_sync_wrote(&oy,og[2].body_len-5);

  1770. 

  1771.       memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,

  1772. 	     og[3].header_len);

  1773.       ogg_sync_wrote(&oy,og[3].header_len);

  1774. 

  1775.       memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,

  1776. 	     og[3].body_len);

  1777.       ogg_sync_wrote(&oy,og[3].body_len);

  1778. 

  1779.       if(ogg_sync_pageout(&oy,&og_de)>0)error();

  1780.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();

  1781. 

  1782.       fprintf(stderr,"ok.\n");

  1783.     }

  1784. 

  1785.     /* Free page data that was previously copied */

  1786.     {

  1787.       for(i=0;i<5;i++){

  1788. 	free_page(&og[i]);

  1789.       }

  1790.     }

  1791.   }

  1792. 

  1793.   return(0);

  1794. }

  1795. 

  1796. #endif