开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
framing.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：39k
源码类别：

VC书籍

开发平台：

Visual C++

framing.c：源码内容
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <ogg/ogg.h>
  8. int ogg_page_version(ogg_page *og){
  9.   return((int)(og->header[4]));
  10. }
  12. int ogg_page_continued(ogg_page *og){
  13.   return((int)(og->header[5]&0x01));
  14. }
  16. int ogg_page_bos(ogg_page *og){
  17.   return((int)(og->header[5]&0x02));
  18. }
  20. int ogg_page_eos(ogg_page *og){
  21.   return((int)(og->header[5]&0x04));
  22. }
  24. ogg_int64_t ogg_page_granulepos(ogg_page *og){
  25.   unsigned char *page=og->header;
  26.   ogg_int64_t granulepos=page[13]&(0xff);
  27.   granulepos= (granulepos<<8)|(page[12]&0xff);
  28.   granulepos= (granulepos<<8)|(page[11]&0xff);
  29.   granulepos= (granulepos<<8)|(page[10]&0xff);
  30.   granulepos= (granulepos<<8)|(page[9]&0xff);
  31.   granulepos= (granulepos<<8)|(page[8]&0xff);
  32.   granulepos= (granulepos<<8)|(page[7]&0xff);
  33.   granulepos= (granulepos<<8)|(page[6]&0xff);
  34.   return(granulepos);
  35. }
  37. int ogg_page_serialno(ogg_page *og){
  38.   return(og->header[14] |
  39.  (og->header[15]<<8) |
  40.  (og->header[16]<<16) |
  41.  (og->header[17]<<24));
  42. }
  43.  
  44. long ogg_page_pageno(ogg_page *og){
  45.   return(og->header[18] |
  46.  (og->header[19]<<8) |
  47.  (og->header[20]<<16) |
  48.  (og->header[21]<<24));
  49. }
  55. int ogg_page_packets(ogg_page *og){
  56.   int i,n=og->header[26],count=0;
  57.   for(i=0;i<n;i++)
  58.     if(og->header[27+i]<255)count++;
  59.   return(count);
  60. }
  63. #if 0
  65. static ogg_uint32_t _ogg_crc_entry(unsigned long index){
  66.   int           i;
  67.   unsigned long r;
  69.   r = index << 24;
  70.   for (i=0; i<8; i++)
  71.     if (r & 0x80000000UL)
  72.       r = (r << 1) ^ 0x04c11db7; 
  73.     else
  74.        r<<=1;
  75.  return (r & 0xffffffffUL);
  76. }
  77. #endif
  79. const ogg_uint32_t crc_lookup[256]={
  80.   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
  81.   0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
  82.   0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
  83.   0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
  84.   0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
  85.   0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
  86.   0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
  87.   0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
  88.   0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
  89.   0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
  90.   0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
  91.   0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
  92.   0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
  93.   0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
  94.   0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
  95.   0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
  96.   0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
  97.   0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
  98.   0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
  99.   0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
  100.   0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
  101.   0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
  102.   0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
  103.   0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
  104.   0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
  105.   0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
  106.   0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
  107.   0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
  108.   0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
  109.   0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
  110.   0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
  111.   0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
  112.   0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
  113.   0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
  114.   0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
  115.   0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
  116.   0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
  117.   0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
  118.   0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
  119.   0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
  120.   0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
  121.   0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
  122.   0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
  123.   0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
  124.   0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
  125.   0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
  126.   0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
  127.   0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
  128.   0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
  129.   0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
  130.   0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
  131.   0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
  132.   0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
  133.   0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
  134.   0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
  135.   0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
  136.   0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
  137.   0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
  138.   0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
  139.   0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
  140.   0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
  141.   0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
  142.   0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
  143.   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
  146. int ogg_stream_init(ogg_stream_state *os,int serialno){
  147.   if(os){
  148.     memset(os,0,sizeof(*os));
  149.     os->body_storage=16*1024;
  150.     os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
  152.     os->lacing_storage=1024;
  153.     os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
  154.     os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
  156.     os->serialno=serialno;
  158.     return(0);
  159.   }
  160.   return(-1);
  161. } 
  163. int ogg_stream_clear(ogg_stream_state *os){
  164.   if(os){
  165.     if(os->body_data)_ogg_free(os->body_data);
  166.     if(os->lacing_vals)_ogg_free(os->lacing_vals);
  167.     if(os->granule_vals)_ogg_free(os->granule_vals);
  169.     memset(os,0,sizeof(*os));    
  170.   }
  171.   return(0);
  172. } 
  174. int ogg_stream_destroy(ogg_stream_state *os){
  175.   if(os){
  176.     ogg_stream_clear(os);
  177.     _ogg_free(os);
  178.   }
  179.   return(0);
  180. } 
  184. static void _os_body_expand(ogg_stream_state *os,int needed){
  185.   if(os->body_storage<=os->body_fill+needed){
  186.     os->body_storage+=(needed+1024);
  187.     os->body_data=_ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));
  188.   }
  189. }
  191. static void _os_lacing_expand(ogg_stream_state *os,int needed){
  192.   if(os->lacing_storage<=os->lacing_fill+needed){
  193.     os->lacing_storage+=(needed+32);
  194.     os->lacing_vals=_ogg_realloc(os->lacing_vals,os->lacing_storage*sizeof(*os->lacing_vals));
  195.     os->granule_vals=_ogg_realloc(os->granule_vals,os->lacing_storage*sizeof(*os->granule_vals));
  196.   }
  197. }
  201. void ogg_page_checksum_set(ogg_page *og){
  202.   if(og){
  203.     ogg_uint32_t crc_reg=0;
  204.     int i;
  206.     og->header[22]=0;
  207.     og->header[23]=0;
  208.     og->header[24]=0;
  209.     og->header[25]=0;
  210.     
  211.     for(i=0;i<og->header_len;i++)
  212.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
  213.     for(i=0;i<og->body_len;i++)
  214.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
  215.     
  216.     og->header[22]=crc_reg&0xff;
  217.     og->header[23]=(crc_reg>>8)&0xff;
  218.     og->header[24]=(crc_reg>>16)&0xff;
  219.     og->header[25]=(crc_reg>>24)&0xff;
  220.   }
  221. }
  223. int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
  224.   int lacing_vals=op->bytes/255+1,i;
  226.   if(os->body_returned){
  227.    
  228.     
  229.     os->body_fill-=os->body_returned;
  230.     if(os->body_fill)
  231.       memmove(os->body_data,os->body_data+os->body_returned,
  232.       os->body_fill);
  233.     os->body_returned=0;
  234.   }
  235.  
  236.   _os_body_expand(os,op->bytes);
  237.   _os_lacing_expand(os,lacing_vals);
  240.   memcpy(os->body_data+os->body_fill,op->packet,op->bytes);
  241.   os->body_fill+=op->bytes;
  243.   for(i=0;i<lacing_vals-1;i++){
  244.     os->lacing_vals[os->lacing_fill+i]=255;
  245.     os->granule_vals[os->lacing_fill+i]=os->granulepos;
  246.   }
  247.   os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;
  248.   os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;
  250.   os->lacing_vals[os->lacing_fill]|= 0x100;
  252.   os->lacing_fill+=lacing_vals;
  254.   os->packetno++;
  256.   if(op->e_o_s)os->e_o_s=1;
  258.   return(0);
  259. }
  263. int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){
  264.   int i;
  265.   int vals=0;
  266.   int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
  267.   int bytes=0;
  268.   long acc=0;
  269.   ogg_int64_t granule_pos=os->granule_vals[0];
  271.   if(maxvals==0)return(0);
  272.   
  273.   
  274.   if(os->b_o_s==0){  
  275.     granule_pos=0;
  276.     for(vals=0;vals<maxvals;vals++){
  277.       if((os->lacing_vals[vals]&0x0ff)<255){
  278. vals++;
  279. break;
  280.       }
  281.     }
  282.   }else{
  283.     for(vals=0;vals<maxvals;vals++){
  284.       if(acc>4096)break;
  285.       acc+=os->lacing_vals[vals]&0x0ff;
  286.       granule_pos=os->granule_vals[vals];
  287.     }
  288.   }
  289.   
  290.   memcpy(os->header,"OggS",4);
  291.   
  292.   os->header[4]=0x00;
  293.   
  294.   os->header[5]=0x00;
  295.   if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;
  296.   if(os->b_o_s==0)os->header[5]|=0x02;
  297.   if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;
  298.   os->b_o_s=1;
  300.   for(i=6;i<14;i++){
  301.     os->header[i]=(granule_pos&0xff);
  302.     granule_pos>>=8;
  303.   }
  305.   {
  306.     long serialno=os->serialno;
  307.     for(i=14;i<18;i++){
  308.       os->header[i]=(serialno&0xff);
  309.       serialno>>=8;
  310.     }
  311.   }
  313.  
  314.   if(os->pageno==-1)os->pageno=0; 
  315.   {
  316.     long pageno=os->pageno++;
  317.     for(i=18;i<22;i++){
  318.       os->header[i]=(pageno&0xff);
  319.       pageno>>=8;
  320.     }
  321.   }
  322.   
  323.   os->header[22]=0;
  324.   os->header[23]=0;
  325.   os->header[24]=0;
  326.   os->header[25]=0;
  327.   
  328.   os->header[26]=vals&0xff;
  329.   for(i=0;i<vals;i++)
  330.     bytes+=os->header[i+27]=(os->lacing_vals[i]&0xff);
  331.   
  332.   og->header=os->header;
  333.   og->header_len=os->header_fill=vals+27;
  334.   og->body=os->body_data+os->body_returned;
  335.   og->body_len=bytes;
  336.   
  337.   
  338.   os->lacing_fill-=vals;
  339.   memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));
  340.   memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));
  341.   os->body_returned+=bytes;
  342.   
  343.   
  344.   ogg_page_checksum_set(og);
  346.   /* done */
  347.   return(1);
  348. }
  353. int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
  355.   if((os->e_o_s&&os->lacing_fill) ||        
  356.      os->body_fill-os->body_returned > 4096 ||
  357.      os->lacing_fill>=255 ||                  
  358.      (os->lacing_fill&&!os->b_o_s)){          
  359.         
  360.     return(ogg_stream_flush(os,og));
  361.   }
  362.   
  363.   return(0);
  364. }
  366. int ogg_stream_eos(ogg_stream_state *os){
  367.   return os->e_o_s;
  368. }
  373. int ogg_sync_init(ogg_sync_state *oy){
  374.   if(oy){
  375.     memset(oy,0,sizeof(*oy));
  376.   }
  377.   return(0);
  378. }
  380. int ogg_sync_clear(ogg_sync_state *oy){
  381.   if(oy){
  382.     if(oy->data)_ogg_free(oy->data);
  383.     ogg_sync_init(oy);
  384.   }
  385.   return(0);
  386. }
  388. int ogg_sync_destroy(ogg_sync_state *oy){
  389.   if(oy){
  390.     ogg_sync_clear(oy);
  391.     _ogg_free(oy);
  392.   }
  393.   return(0);
  394. }
  396. char *ogg_sync_buffer(ogg_sync_state *oy, long size){
  398.   if(oy->returned){
  399.     oy->fill-=oy->returned;
  400.     if(oy->fill>0)
  401.       memmove(oy->data,oy->data+oy->returned,oy->fill);
  402.     oy->returned=0;
  403.   }
  405.   if(size>oy->storage-oy->fill){
  406.     long newsize=size+oy->fill+4096; 
  408.     if(oy->data)
  409.       oy->data=_ogg_realloc(oy->data,newsize);
  410.     else
  411.       oy->data=_ogg_malloc(newsize);
  412.     oy->storage=newsize;
  413.   }
  415.   return((char *)oy->data+oy->fill);
  416. }
  418. int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
  419.   if(oy->fill+bytes>oy->storage)return(-1);
  420.   oy->fill+=bytes;
  421.   return(0);
  422. }
  426. long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
  427.   unsigned char *page=oy->data+oy->returned;
  428.   unsigned char *next;
  429.   long bytes=oy->fill-oy->returned;
  430.   
  431.   if(oy->headerbytes==0){
  432.     int headerbytes,i;
  433.     if(bytes<27)return(0); 
  434.     
  435.     if(memcmp(page,"OggS",4))goto sync_fail;
  436.     
  437.     headerbytes=page[26]+27;
  438.     if(bytes<headerbytes)return(0); 
  439.     
  440.     
  441.     for(i=0;i<page[26];i++)
  442.       oy->bodybytes+=page[27+i];
  443.     oy->headerbytes=headerbytes;
  444.   }
  445.   
  446.   if(oy->bodybytes+oy->headerbytes>bytes)return(0);
  447.   
  448.   {
  449.     char chksum[4];
  450.     ogg_page log;
  451.     
  452.     memcpy(chksum,page+22,4);
  453.     memset(page+22,0,4);
  454.     
  455.     log.header=page;
  456.     log.header_len=oy->headerbytes;
  457.     log.body=page+oy->headerbytes;
  458.     log.body_len=oy->bodybytes;
  459.     ogg_page_checksum_set(&log);
  460.     
  461.     if(memcmp(chksum,page+22,4)){
  462.   
  463.       memcpy(page+22,chksum,4);
  464.       
  465.       goto sync_fail;
  466.     }
  467.   }
  468.   
  469.   {
  470.     unsigned char *page=oy->data+oy->returned;
  471.     long bytes;
  473.     if(og){
  474.       og->header=page;
  475.       og->header_len=oy->headerbytes;
  476.       og->body=page+oy->headerbytes;
  477.       og->body_len=oy->bodybytes;
  478.     }
  480.     oy->unsynced=0;
  481.     oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
  482.     oy->headerbytes=0;
  483.     oy->bodybytes=0;
  484.     return(bytes);
  485.   }
  486.   
  487.  sync_fail:
  488.   
  489.   oy->headerbytes=0;
  490.   oy->bodybytes=0;
  491.   
  492.   next=memchr(page+1,'O',bytes-1);
  493.   if(!next)
  494.     next=oy->data+oy->fill;
  496.   oy->returned=next-oy->data;
  497.   return(-(next-page));
  498. }
  501. int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
  503.   
  504.   while(1){
  505.     long ret=ogg_sync_pageseek(oy,og);
  506.     if(ret>0){
  507.       return(1);
  508.     }
  509.     if(ret==0){
  510.       return(0);
  511.     }
  512.     
  513.     if(!oy->unsynced){
  514.       oy->unsynced=1;
  515.       return(-1);
  516.     }
  519.   }
  520. }
  523. int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
  524.   unsigned char *header=og->header;
  525.   unsigned char *body=og->body;
  526.   long           bodysize=og->body_len;
  527.   int            segptr=0;
  529.   int version=ogg_page_version(og);
  530.   int continued=ogg_page_continued(og);
  531.   int bos=ogg_page_bos(og);
  532.   int eos=ogg_page_eos(og);
  533.   ogg_int64_t granulepos=ogg_page_granulepos(og);
  534.   int serialno=ogg_page_serialno(og);
  535.   long pageno=ogg_page_pageno(og);
  536.   int segments=header[26];
  537.   
  538.   {
  539.     long lr=os->lacing_returned;
  540.     long br=os->body_returned;
  542.     if(br){
  543.       os->body_fill-=br;
  544.       if(os->body_fill)
  545. memmove(os->body_data,os->body_data+br,os->body_fill);
  546.       os->body_returned=0;
  547.     }
  549.     if(lr){
  550.       if(os->lacing_fill-lr){
  551. memmove(os->lacing_vals,os->lacing_vals+lr,
  552. (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
  553. memmove(os->granule_vals,os->granule_vals+lr,
  554. (os->lacing_fill-lr)*sizeof(*os->granule_vals));
  555.       }
  556.       os->lacing_fill-=lr;
  557.       os->lacing_packet-=lr;
  558.       os->lacing_returned=0;
  559.     }
  560.   }
  562.   if(serialno!=os->serialno)return(-1);
  563.   if(version>0)return(-1);
  565.   _os_lacing_expand(os,segments+1);
  567.   if(pageno!=os->pageno){
  568.     int i;
  570.     for(i=os->lacing_packet;i<os->lacing_fill;i++)
  571.       os->body_fill-=os->lacing_vals[i]&0xff;
  572.     os->lacing_fill=os->lacing_packet;
  574.     if(os->pageno!=-1){
  575.       os->lacing_vals[os->lacing_fill++]=0x400;
  576.       os->lacing_packet++;
  577.     }
  579.    
  580.     if(continued){
  581.       bos=0;
  582.       for(;segptr<segments;segptr++){
  583. int val=header[27+segptr];
  584. body+=val;
  585. bodysize-=val;
  586. if(val<255){
  587.   segptr++;
  588.   break;
  589. }
  590.       }
  591.     }
  592.   }
  593.   
  594.   if(bodysize){
  595.     _os_body_expand(os,bodysize);
  596.     memcpy(os->body_data+os->body_fill,body,bodysize);
  597.     os->body_fill+=bodysize;
  598.   }
  600.   {
  601.     int saved=-1;
  602.     while(segptr<segments){
  603.       int val=header[27+segptr];
  604.       os->lacing_vals[os->lacing_fill]=val;
  605.       os->granule_vals[os->lacing_fill]=-1;
  606.       
  607.       if(bos){
  608. os->lacing_vals[os->lacing_fill]|=0x100;
  609. bos=0;
  610.       }
  611.       
  612.       if(val<255)saved=os->lacing_fill;
  613.       
  614.       os->lacing_fill++;
  615.       segptr++;
  616.       
  617.       if(val<255)os->lacing_packet=os->lacing_fill;
  618.     }
  619.   
  620.     if(saved!=-1){
  621.       os->granule_vals[saved]=granulepos;
  622.     }
  624.   }
  626.   if(eos){
  627.     os->e_o_s=1;
  628.     if(os->lacing_fill>0)
  629.       os->lacing_vals[os->lacing_fill-1]|=0x200;
  630.   }
  632.   os->pageno=pageno+1;
  634.   return(0);
  635. }
  637. int ogg_sync_reset(ogg_sync_state *oy){
  638.   oy->fill=0;
  639.   oy->returned=0;
  640.   oy->unsynced=0;
  641.   oy->headerbytes=0;
  642.   oy->bodybytes=0;
  643.   return(0);
  644. }
  646. int ogg_stream_reset(ogg_stream_state *os){
  647.   os->body_fill=0;
  648.   os->body_returned=0;
  650.   os->lacing_fill=0;
  651.   os->lacing_packet=0;
  652.   os->lacing_returned=0;
  654.   os->header_fill=0;
  656.   os->e_o_s=0;
  657.   os->b_o_s=0;
  658.   os->pageno=-1;
  659.   os->packetno=0;
  660.   os->granulepos=0;
  662.   return(0);
  663. }
  665. int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
  666.   ogg_stream_reset(os);
  667.   os->serialno=serialno;
  668.   return(0);
  669. }
  671. static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
  673.   
  674.   int ptr=os->lacing_returned;
  676.   if(os->lacing_packet<=ptr)return(0);
  678.   if(os->lacing_vals[ptr]&0x400){
  679.     
  680.     os->lacing_returned++;
  681.     os->packetno++;
  682.     return(-1);
  683.   }
  685.   if(!op && !adv)return(1); 
  687.   {
  688.     int size=os->lacing_vals[ptr]&0xff;
  689.     int bytes=size;
  690.     int eos=os->lacing_vals[ptr]&0x200; 
  691.     int bos=os->lacing_vals[ptr]&0x100; 
  693.     while(size==255){
  694.       int val=os->lacing_vals[++ptr];
  695.       size=val&0xff;
  696.       if(val&0x200)eos=0x200;
  697.       bytes+=size;
  698.     }
  700.     if(op){
  701.       op->e_o_s=eos;
  702.       op->b_o_s=bos;
  703.       op->packet=os->body_data+os->body_returned;
  704.       op->packetno=os->packetno;
  705.       op->granulepos=os->granule_vals[ptr];
  706.       op->bytes=bytes;
  707.     }
  709.     if(adv){
  710.       os->body_returned+=bytes;
  711.       os->lacing_returned=ptr+1;
  712.       os->packetno++;
  713.     }
  714.   }
  715.   return(1);
  716. }
  718. int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
  719.   return _packetout(os,op,1);
  720. }
  722. int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
  723.   return _packetout(os,op,0);
  724. }
  726. void ogg_packet_clear(ogg_packet *op) {
  727.   _ogg_free(op->packet);
  728.   memset(op, 0, sizeof(*op));
  729. }
  731. #ifdef _V_SELFTEST
  732. #include <stdio.h>
  734. ogg_stream_state os_en, os_de;
  735. ogg_sync_state oy;
  737. void checkpacket(ogg_packet *op,int len, int no, int pos){
  738.   long j;
  739.   static int sequence=0;
  740.   static int lastno=0;
  742.   if(op->bytes!=len){
  743.     fprintf(stderr,"incorrect packet length!n");
  744.     exit(1);
  745.   }
  746.   if(op->granulepos!=pos){
  747.     fprintf(stderr,"incorrect packet position!n");
  748.     exit(1);
  749.   }
  751.   
  752.   if(no==0){
  753.     sequence=0;
  754.   }else{
  755.     sequence++;
  756.     if(no>lastno+1)
  757.       sequence++;
  758.   }
  759.   lastno=no;
  760.   if(op->packetno!=sequence){
  761.     fprintf(stderr,"incorrect packet sequence %ld != %dn",
  762.     (long)(op->packetno),sequence);
  763.     exit(1);
  764.   }
  766.   for(j=0;j<op->bytes;j++)
  767.     if(op->packet[j]!=((j+no)&0xff)){
  768.       fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!nn",
  769.       j,op->packet[j],(j+no)&0xff);
  770.       exit(1);
  771.     }
  772. }
  774. void check_page(unsigned char *data,const int *header,ogg_page *og){
  775.   long j;
  776.   for(j=0;j<og->body_len;j++)
  777.     if(og->body[j]!=data[j]){
  778.       fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!nn",
  779.       j,data[j],og->body[j]);
  780.       exit(1);
  781.     }
  783.   for(j=0;j<og->header_len;j++){
  784.     if(og->header[j]!=header[j]){
  785.       fprintf(stderr,"header content mismatch at pos %ld:n",j);
  786.       for(j=0;j<header[26]+27;j++)
  787. fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
  788.       fprintf(stderr,"n");
  789.       exit(1);
  790.     }
  791.   }
  792.   if(og->header_len!=header[26]+27){
  793.     fprintf(stderr,"header length incorrect! (%ld!=%d)n",
  794.     og->header_len,header[26]+27);
  795.     exit(1);
  796.   }
  797. }
  799. void print_header(ogg_page *og){
  800.   int j;
  801.   fprintf(stderr,"nHEADER:n");
  802.   fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %xn",
  803.   og->header[0],og->header[1],og->header[2],og->header[3],
  804.   (int)og->header[4],(int)og->header[5]);
  806.   fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ldn",
  807.   (og->header[9]<<24)|(og->header[8]<<16)|
  808.   (og->header[7]<<8)|og->header[6],
  809.   (og->header[17]<<24)|(og->header[16]<<16)|
  810.   (og->header[15]<<8)|og->header[14],
  811.   ((long)(og->header[21])<<24)|(og->header[20]<<16)|
  812.   (og->header[19]<<8)|og->header[18]);
  814.   fprintf(stderr,"  checksum: %02x:%02x:%02x:%02xn  segments: %d (",
  815.   (int)og->header[22],(int)og->header[23],
  816.   (int)og->header[24],(int)og->header[25],
  817.   (int)og->header[26]);
  819.   for(j=27;j<og->header_len;j++)
  820.     fprintf(stderr,"%d ",(int)og->header[j]);
  821.   fprintf(stderr,")nn");
  822. }
  824. void copy_page(ogg_page *og){
  825.   unsigned char *temp=_ogg_malloc(og->header_len);
  826.   memcpy(temp,og->header,og->header_len);
  827.   og->header=temp;
  829.   temp=_ogg_malloc(og->body_len);
  830.   memcpy(temp,og->body,og->body_len);
  831.   og->body=temp;
  832. }
  834. void error(void){
  835.   fprintf(stderr,"error!n");
  836.   exit(1);
  837. }
  839. /* 17 only */
  840. const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
  841.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  842.        0x01,0x02,0x03,0x04,0,0,0,0,
  843.        0x15,0xed,0xec,0x91,
  844.        1,
  845.        17};
  847. /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
  848. const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
  849.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  850.        0x01,0x02,0x03,0x04,0,0,0,0,
  851.        0x59,0x10,0x6c,0x2c,
  852.        1,
  853.        17};
  854. const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
  855.        0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
  856.        0x01,0x02,0x03,0x04,1,0,0,0,
  857.        0x89,0x33,0x85,0xce,
  858.        13,
  859.        254,255,0,255,1,255,245,255,255,0,
  860.        255,255,90};
  862. const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
  863.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  864.        0x01,0x02,0x03,0x04,0,0,0,0,
  865.        0xff,0x7b,0x23,0x17,
  866.        1,
  867.        0};
  868. const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
  869.        0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
  870.        0x01,0x02,0x03,0x04,1,0,0,0,
  871.        0x5c,0x3f,0x66,0xcb,
  872.        17,
  873.        17,254,255,0,0,255,1,0,255,245,255,255,0,
  874.        255,255,90,0};
  876. const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
  877.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  878.        0x01,0x02,0x03,0x04,0,0,0,0,
  879.        0x01,0x27,0x31,0xaa,
  880.        18,
  881.        255,255,255,255,255,255,255,255,
  882.        255,255,255,255,255,255,255,255,255,10};
  884. const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
  885.        0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
  886.        0x01,0x02,0x03,0x04,1,0,0,0,
  887.        0x7f,0x4e,0x8a,0xd2,
  888.        4,
  889.        255,4,255,0};
  892. const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
  893.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  894.        0x01,0x02,0x03,0x04,0,0,0,0,
  895.        0xff,0x7b,0x23,0x17,
  896.        1,
  897.        0};
  899. const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
  900.        0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  901.        0x01,0x02,0x03,0x04,1,0,0,0,
  902.        0x34,0x24,0xd5,0x29,
  903.        17,
  904.        255,255,255,255,255,255,255,255,
  905.        255,255,255,255,255,255,255,255,255};
  907. const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
  908.        0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
  909.        0x01,0x02,0x03,0x04,2,0,0,0,
  910.        0xc8,0xc3,0xcb,0xed,
  911.        5,
  912.        10,255,4,255,0};
  915. const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
  916.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  917.        0x01,0x02,0x03,0x04,0,0,0,0,
  918.        0xff,0x7b,0x23,0x17,
  919.        1,
  920.        0};
  922. const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
  923.        0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
  924.        0x01,0x02,0x03,0x04,1,0,0,0,
  925.        0xed,0x2a,0x2e,0xa7,
  926.        255,
  927.        10,10,10,10,10,10,10,10,
  928.        10,10,10,10,10,10,10,10,
  929.        10,10,10,10,10,10,10,10,
  930.        10,10,10,10,10,10,10,10,
  931.        10,10,10,10,10,10,10,10,
  932.        10,10,10,10,10,10,10,10,
  933.        10,10,10,10,10,10,10,10,
  934.        10,10,10,10,10,10,10,10,
  935.        10,10,10,10,10,10,10,10,
  936.        10,10,10,10,10,10,10,10,
  937.        10,10,10,10,10,10,10,10,
  938.        10,10,10,10,10,10,10,10,
  939.        10,10,10,10,10,10,10,10,
  940.        10,10,10,10,10,10,10,10,
  941.        10,10,10,10,10,10,10,10,
  942.        10,10,10,10,10,10,10,10,
  943.        10,10,10,10,10,10,10,10,
  944.        10,10,10,10,10,10,10,10,
  945.        10,10,10,10,10,10,10,10,
  946.        10,10,10,10,10,10,10,10,
  947.        10,10,10,10,10,10,10,10,
  948.        10,10,10,10,10,10,10,10,
  949.        10,10,10,10,10,10,10,10,
  950.        10,10,10,10,10,10,10,10,
  951.        10,10,10,10,10,10,10,10,
  952.        10,10,10,10,10,10,10,10,
  953.        10,10,10,10,10,10,10,10,
  954.        10,10,10,10,10,10,10,10,
  955.        10,10,10,10,10,10,10,10,
  956.        10,10,10,10,10,10,10,10,
  957.        10,10,10,10,10,10,10,10,
  958.        10,10,10,10,10,10,10};
  960. const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
  961.        0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
  962.        0x01,0x02,0x03,0x04,2,0,0,0,
  963.        0x6c,0x3b,0x82,0x3d,
  964.        1,
  965.        50};
  968. const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
  969.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  970.        0x01,0x02,0x03,0x04,0,0,0,0,
  971.        0xff,0x7b,0x23,0x17,
  972.        1,
  973.        0};
  975. const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
  976.        0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  977.        0x01,0x02,0x03,0x04,1,0,0,0,
  978.        0x3c,0xd9,0x4d,0x3f,
  979.        17,
  980.        100,255,255,255,255,255,255,255,255,
  981.        255,255,255,255,255,255,255,255};
  983. const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
  984.        0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  985.        0x01,0x02,0x03,0x04,2,0,0,0,
  986.        0xbd,0xd5,0xb5,0x8b,
  987.        17,
  988.        255,255,255,255,255,255,255,255,
  989.        255,255,255,255,255,255,255,255,255};
  991. const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
  992.        0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
  993.        0x01,0x02,0x03,0x04,3,0,0,0,
  994.        0xef,0xdd,0x88,0xde,
  995.        7,
  996.        255,255,75,255,4,255,0};
  998. const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
  999.        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1000.        0x01,0x02,0x03,0x04,0,0,0,0,
  1001.        0xff,0x7b,0x23,0x17,
  1002.        1,
  1003.        0};
  1005. const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
  1006.        0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  1007.        0x01,0x02,0x03,0x04,1,0,0,0,
  1008.        0x3c,0xd9,0x4d,0x3f,
  1009.        17,
  1010.        100,255,255,255,255,255,255,255,255,
  1011.        255,255,255,255,255,255,255,255};
  1013. const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
  1014.        0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
  1015.        0x01,0x02,0x03,0x04,2,0,0,0,
  1016.        0xd4,0xe0,0x60,0xe5,
  1017.        1,0};
  1019. void test_pack(const int *pl, const int **headers){
  1020.   unsigned char *data=_ogg_malloc(1024*1024); 
  1021.   long inptr=0;
  1022.   long outptr=0;
  1023.   long deptr=0;
  1024.   long depacket=0;
  1025.   long granule_pos=7,pageno=0;
  1026.   int i,j,packets,pageout=0;
  1027.   int eosflag=0;
  1028.   int bosflag=0;
  1030.   ogg_stream_reset(&os_en);
  1031.   ogg_stream_reset(&os_de);
  1032.   ogg_sync_reset(&oy);
  1034.   for(packets=0;;packets++)if(pl[packets]==-1)break;
  1036.   for(i=0;i<packets;i++){
  1037.     ogg_packet op;
  1038.     int len=pl[i];
  1039.     
  1040.     op.packet=data+inptr;
  1041.     op.bytes=len;
  1042.     op.e_o_s=(pl[i+1]<0?1:0);
  1043.     op.granulepos=granule_pos;
  1045.     granule_pos+=1024;
  1047.     for(j=0;j<len;j++)data[inptr++]=i+j;
  1049.     ogg_stream_packetin(&os_en,&op);
  1051.     {
  1052.       ogg_page og;
  1053.       
  1054.       while(ogg_stream_pageout(&os_en,&og)){
  1056. fprintf(stderr,"%ld, ",pageno);
  1058. if(headers[pageno]==NULL){
  1059.   fprintf(stderr,"coded too many pages!n");
  1060.   exit(1);
  1061. }
  1063. check_page(data+outptr,headers[pageno],&og);
  1065. outptr+=og.body_len;
  1066. pageno++;
  1069. {
  1070.   ogg_page og_de;
  1071.   ogg_packet op_de,op_de2;
  1072.   char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
  1073.   memcpy(buf,og.header,og.header_len);
  1074.   memcpy(buf+og.header_len,og.body,og.body_len);
  1075.   ogg_sync_wrote(&oy,og.header_len+og.body_len);
  1077.   while(ogg_sync_pageout(&oy,&og_de)>0){
  1078.     
  1079.     check_page(data+deptr,headers[pageout],&og_de);
  1080.     deptr+=og_de.body_len;
  1081.     pageout++;
  1083.     ogg_stream_pagein(&os_de,&og_de);
  1085.     while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
  1086.       ogg_stream_packetpeek(&os_de,NULL);
  1087.       ogg_stream_packetout(&os_de,&op_de); 
  1088.       
  1089.       if(memcmp(&op_de,&op_de2,sizeof(op_de))){
  1090. fprintf(stderr,"packetout != packetpeek! pos=%ldn",
  1091. depacket);
  1092. exit(1);
  1093.       }
  1095.      
  1096.       if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
  1097. fprintf(stderr,"packet data mismatch in decode! pos=%ldn",
  1098. depacket);
  1099. exit(1);
  1100.       }
  1101.       if(bosflag==0 && op_de.b_o_s==0){
  1102. fprintf(stderr,"b_o_s flag not set on packet!n");
  1103. exit(1);
  1104.       }
  1105.       if(bosflag && op_de.b_o_s){
  1106. fprintf(stderr,"b_o_s flag incorrectly set on packet!n");
  1107. exit(1);
  1108.       }
  1109.       bosflag=1;
  1110.       depacket+=op_de.bytes;
  1111.       
  1112.       if(eosflag){
  1113. fprintf(stderr,"Multiple decoded packets with eos flag!n");
  1114. exit(1);
  1115.       }
  1117.       if(op_de.e_o_s)eosflag=1;
  1119.       if(op_de.granulepos!=-1){
  1120. fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
  1121.       }
  1122.     }
  1123.   }
  1124. }
  1125.       }
  1126.     }
  1127.   }
  1128.   _ogg_free(data);
  1129.   if(headers[pageno]!=NULL){
  1130.     fprintf(stderr,"did not write last page!n");
  1131.     exit(1);
  1132.   }
  1133.   if(headers[pageout]!=NULL){
  1134.     fprintf(stderr,"did not decode last page!n");
  1135.     exit(1);
  1136.   }
  1137.   if(inptr!=outptr){
  1138.     fprintf(stderr,"encoded page data incomplete!n");
  1139.     exit(1);
  1140.   }
  1141.   if(inptr!=deptr){
  1142.     fprintf(stderr,"decoded page data incomplete!n");
  1143.     exit(1);
  1144.   }
  1145.   if(inptr!=depacket){
  1146.     fprintf(stderr,"decoded packet data incomplete!n");
  1147.     exit(1);
  1148.   }
  1149.   if(!eosflag){
  1150.     fprintf(stderr,"Never got a packet with EOS set!n");
  1151.     exit(1);
  1152.   }
  1153.   fprintf(stderr,"ok.n");
  1154. }
  1156. int main(void){
  1158.   ogg_stream_init(&os_en,0x04030201);
  1159.   ogg_stream_init(&os_de,0x04030201);
  1160.   ogg_sync_init(&oy);
  1162.   
  1163.   {
  1164.     /* 17 only */
  1165.     const int packets[]={17, -1};
  1166.     const int *headret[]={head1_0,NULL};
  1167.     
  1168.     fprintf(stderr,"testing single page encoding... ");
  1169.     test_pack(packets,headret);
  1170.   }
  1172.   {
  1173.     /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
  1174.     const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};
  1175.     const int *headret[]={head1_1,head2_1,NULL};
  1176.     
  1177.     fprintf(stderr,"testing basic page encoding... ");
  1178.     test_pack(packets,headret);
  1179.   }
  1181.   {
  1182.     const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};
  1183.     const int *headret[]={head1_2,head2_2,NULL};
  1184.     
  1185.     fprintf(stderr,"testing basic nil packets... ");
  1186.     test_pack(packets,headret);
  1187.   }
  1189.   {
  1190.     const int packets[]={4345,259,255,-1};
  1191.     const int *headret[]={head1_3,head2_3,NULL};
  1192.     
  1193.     fprintf(stderr,"testing initial-packet lacing > 4k... ");
  1194.     test_pack(packets,headret);
  1195.   }
  1197.   {
  1198.     const int packets[]={0,4345,259,255,-1};
  1199.     const int *headret[]={head1_4,head2_4,head3_4,NULL};
  1200.     
  1201.     fprintf(stderr,"testing single packet page span... ");
  1202.     test_pack(packets,headret);
  1203.   }
  1205.   {
  1207.     const int packets[]={0,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,10,
  1222.    10,10,10,10,10,10,10,10,
  1223.    10,10,10,10,10,10,10,10,
  1224.    10,10,10,10,10,10,10,10,
  1225.    10,10,10,10,10,10,10,10,
  1226.    10,10,10,10,10,10,10,10,
  1227.    10,10,10,10,10,10,10,10,
  1228.    10,10,10,10,10,10,10,10,
  1229.    10,10,10,10,10,10,10,10,
  1230.    10,10,10,10,10,10,10,10,
  1231.    10,10,10,10,10,10,10,10,
  1232.    10,10,10,10,10,10,10,10,
  1233.    10,10,10,10,10,10,10,10,
  1234.    10,10,10,10,10,10,10,10,
  1235.    10,10,10,10,10,10,10,10,
  1236.    10,10,10,10,10,10,10,10,
  1237.    10,10,10,10,10,10,10,10,
  1238.    10,10,10,10,10,10,10,50,-1};
  1239.     const int *headret[]={head1_5,head2_5,head3_5,NULL};
  1240.     
  1241.     fprintf(stderr,"testing max packet segments... ");
  1242.     test_pack(packets,headret);
  1243.   }
  1245.   {
  1246.     const int packets[]={0,100,9000,259,255,-1};
  1247.     const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
  1248.     
  1249.     fprintf(stderr,"testing very large packets... ");
  1250.     test_pack(packets,headret);
  1251.   }
  1253.   {
  1254.     const int packets[]={0,100,4080,-1};
  1255.     const int *headret[]={head1_7,head2_7,head3_7,NULL};
  1256.     
  1257.     fprintf(stderr,"testing zero data page (1 nil packet)... ");
  1258.     test_pack(packets,headret);
  1259.   }
  1263.   {
  1264.     unsigned char *data=_ogg_malloc(1024*1024);
  1265.     int pl[]={0,100,4079,2956,2057,76,34,912,0,234,1000,1000,1000,300,-1};
  1266.     int inptr=0,i,j;
  1267.     ogg_page og[5];
  1268.     
  1269.     ogg_stream_reset(&os_en);
  1271.     for(i=0;pl[i]!=-1;i++){
  1272.       ogg_packet op;
  1273.       int len=pl[i];
  1274.       
  1275.       op.packet=data+inptr;
  1276.       op.bytes=len;
  1277.       op.e_o_s=(pl[i+1]<0?1:0);
  1278.       op.granulepos=(i+1)*1000;
  1280.       for(j=0;j<len;j++)data[inptr++]=i+j;
  1281.       ogg_stream_packetin(&os_en,&op);
  1282.     }
  1284.     _ogg_free(data);
  1286.     for(i=0;i<5;i++){
  1287.       if(ogg_stream_pageout(&os_en,&og[i])==0){
  1288. fprintf(stderr,"Too few pages output building sync tests!n");
  1289. exit(1);
  1290.       }
  1291.       copy_page(&og[i]);
  1292.     }
  1294.     {
  1295.       ogg_page temp;
  1296.       ogg_packet test;
  1298.       fprintf(stderr,"Testing loss of pages... ");
  1300.       ogg_sync_reset(&oy);
  1301.       ogg_stream_reset(&os_de);
  1302.       for(i=0;i<5;i++){
  1303. memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
  1304.        og[i].header_len);
  1305. ogg_sync_wrote(&oy,og[i].header_len);
  1306. memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
  1307. ogg_sync_wrote(&oy,og[i].body_len);
  1308.       }
  1310.       ogg_sync_pageout(&oy,&temp);
  1311.       ogg_stream_pagein(&os_de,&temp);
  1312.       ogg_sync_pageout(&oy,&temp);
  1313.       ogg_stream_pagein(&os_de,&temp);
  1314.       ogg_sync_pageout(&oy,&temp);
  1315.       /* skip */
  1316.       ogg_sync_pageout(&oy,&temp);
  1317.       ogg_stream_pagein(&os_de,&temp);
  1319.       
  1320.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1321.       checkpacket(&test,0,0,0);
  1322.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1323.       checkpacket(&test,100,1,-1);
  1324.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1325.       checkpacket(&test,4079,2,3000);
  1326.       if(ogg_stream_packetout(&os_de,&test)!=-1){
  1327. fprintf(stderr,"Error: loss of page did not return errorn");
  1328. exit(1);
  1329.       }
  1330.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1331.       checkpacket(&test,76,5,-1);
  1332.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1333.       checkpacket(&test,34,6,-1);
  1334.       fprintf(stderr,"ok.n");
  1335.     }
  1337.     /* Test lost pages on pagein/packetout: rollback with continuation */
  1338.     {
  1339.       ogg_page temp;
  1340.       ogg_packet test;
  1342.       fprintf(stderr,"Testing loss of pages (rollback required)... ");
  1344.       ogg_sync_reset(&oy);
  1345.       ogg_stream_reset(&os_de);
  1346.       for(i=0;i<5;i++){
  1347. memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
  1348.        og[i].header_len);
  1349. ogg_sync_wrote(&oy,og[i].header_len);
  1350. memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
  1351. ogg_sync_wrote(&oy,og[i].body_len);
  1352.       }
  1354.       ogg_sync_pageout(&oy,&temp);
  1355.       ogg_stream_pagein(&os_de,&temp);
  1356.       ogg_sync_pageout(&oy,&temp);
  1357.       ogg_stream_pagein(&os_de,&temp);
  1358.       ogg_sync_pageout(&oy,&temp);
  1359.       ogg_stream_pagein(&os_de,&temp);
  1360.       ogg_sync_pageout(&oy,&temp);
  1361.       /* skip */
  1362.       ogg_sync_pageout(&oy,&temp);
  1363.       ogg_stream_pagein(&os_de,&temp);
  1365.       
  1366.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1367.       checkpacket(&test,0,0,0);
  1368.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1369.       checkpacket(&test,100,1,-1);
  1370.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1371.       checkpacket(&test,4079,2,3000);
  1372.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1373.       checkpacket(&test,2956,3,4000);
  1374.       if(ogg_stream_packetout(&os_de,&test)!=-1){
  1375. fprintf(stderr,"Error: loss of page did not return errorn");
  1376. exit(1);
  1377.       }
  1378.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1379.       checkpacket(&test,300,13,14000);
  1380.       fprintf(stderr,"ok.n");
  1381.     }
  1382.     
  1383.     {
  1384.       ogg_page og_de;
  1385.       fprintf(stderr,"Testing sync on partial inputs... ");
  1386.       ogg_sync_reset(&oy);
  1387.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1388.      3);
  1389.       ogg_sync_wrote(&oy,3);
  1390.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1391.       
  1392.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
  1393.      20);
  1394.       ogg_sync_wrote(&oy,20);
  1395.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1396.       
  1397.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
  1398.      5);
  1399.       ogg_sync_wrote(&oy,5);
  1400.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1401.       
  1402.       
  1403.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
  1404.      og[1].header_len-28);
  1405.       ogg_sync_wrote(&oy,og[1].header_len-28);
  1406.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1407.       
  1408.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
  1409.       ogg_sync_wrote(&oy,1000);
  1410.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1411.       
  1412.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
  1413.      og[1].body_len-1000);
  1414.       ogg_sync_wrote(&oy,og[1].body_len-1000);
  1415.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1416.       
  1417.       fprintf(stderr,"ok.n");
  1418.     }
  1420.     {
  1421.       ogg_page og_de;
  1422.       fprintf(stderr,"Testing sync on 1+partial inputs... ");
  1423.       ogg_sync_reset(&oy); 
  1425.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1426.      og[1].header_len);
  1427.       ogg_sync_wrote(&oy,og[1].header_len);
  1429.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1430.      og[1].body_len);
  1431.       ogg_sync_wrote(&oy,og[1].body_len);
  1433.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1434.      20);
  1435.       ogg_sync_wrote(&oy,20);
  1436.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1437.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1439.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
  1440.      og[1].header_len-20);
  1441.       ogg_sync_wrote(&oy,og[1].header_len-20);
  1442.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1443.      og[1].body_len);
  1444.       ogg_sync_wrote(&oy,og[1].body_len);
  1445.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1447.       fprintf(stderr,"ok.n");
  1448.     }
  1449.     
  1450.     {
  1451.       ogg_page og_de;
  1452.       fprintf(stderr,"Testing search for capture... ");
  1453.       ogg_sync_reset(&oy); 
  1454.       
  1455.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1456.      og[1].body_len);
  1457.       ogg_sync_wrote(&oy,og[1].body_len);
  1459.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1460.      og[1].header_len);
  1461.       ogg_sync_wrote(&oy,og[1].header_len);
  1463.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1464.      og[1].body_len);
  1465.       ogg_sync_wrote(&oy,og[1].body_len);
  1467.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1468.      20);
  1469.       ogg_sync_wrote(&oy,20);
  1470.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1471.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1472.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1474.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
  1475.      og[2].header_len-20);
  1476.       ogg_sync_wrote(&oy,og[2].header_len-20);
  1477.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
  1478.      og[2].body_len);
  1479.       ogg_sync_wrote(&oy,og[2].body_len);
  1480.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1482.       fprintf(stderr,"ok.n");
  1483.     }
  1485.     {
  1486.       ogg_page og_de;
  1487.       fprintf(stderr,"Testing recapture... ");
  1488.       ogg_sync_reset(&oy); 
  1490.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1491.      og[1].header_len);
  1492.       ogg_sync_wrote(&oy,og[1].header_len);
  1494.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1495.      og[1].body_len);
  1496.       ogg_sync_wrote(&oy,og[1].body_len);
  1498.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1499.      og[2].header_len);
  1500.       ogg_sync_wrote(&oy,og[2].header_len);
  1502.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1503.      og[2].header_len);
  1504.       ogg_sync_wrote(&oy,og[2].header_len);
  1506.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1508.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
  1509.      og[2].body_len-5);
  1510.       ogg_sync_wrote(&oy,og[2].body_len-5);
  1512.       memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
  1513.      og[3].header_len);
  1514.       ogg_sync_wrote(&oy,og[3].header_len);
  1516.       memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
  1517.      og[3].body_len);
  1518.       ogg_sync_wrote(&oy,og[3].body_len);
  1520.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1521.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1523.       fprintf(stderr,"ok.n");
  1524.     }
  1525.   }    
  1527.   return(0);
  1528. }
  1530. #endif