vrshoot: libs/ogg/framing.c annotate

vrshoot

annotate libs/ogg/framing.c @ 2:334d17aed7de

visual studio project files

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sun, 02 Feb 2014 18:36:38 +0200
parents
children

rev	line source
nuclear@0	1 /********************************************************************
nuclear@0	2 * *
nuclear@0	3 * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE. *
nuclear@0	4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
nuclear@0	5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
nuclear@0	6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
nuclear@0	7 * *
nuclear@0	8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
nuclear@0	9 * by the Xiph.Org Foundation http://www.xiph.org/ *
nuclear@0	10 * *
nuclear@0	11 ********************************************************************
nuclear@0	12
nuclear@0	13 function: code raw packets into framed OggSquish stream and
nuclear@0	14 decode Ogg streams back into raw packets
nuclear@0	15 last mod: $Id: framing.c 18758 2013-01-08 16:29:56Z tterribe $
nuclear@0	16
nuclear@0	17 note: The CRC code is directly derived from public domain code by
nuclear@0	18 Ross Williams (ross@guest.adelaide.edu.au). See docs/framing.html
nuclear@0	19 for details.
nuclear@0	20
nuclear@0	21 ********************************************************************/
nuclear@0	22
nuclear@0	23 #include <stdlib.h>
nuclear@0	24 #include <limits.h>
nuclear@0	25 #include <string.h>
nuclear@0	26 #include <ogg/ogg.h>
nuclear@0	27
nuclear@0	28 /* A complete description of Ogg framing exists in docs/framing.html */
nuclear@0	29
nuclear@0	30 int ogg_page_version(const ogg_page *og){
nuclear@0	31 return((int)(og->header[4]));
nuclear@0	32 }
nuclear@0	33
nuclear@0	34 int ogg_page_continued(const ogg_page *og){
nuclear@0	35 return((int)(og->header[5]&0x01));
nuclear@0	36 }
nuclear@0	37
nuclear@0	38 int ogg_page_bos(const ogg_page *og){
nuclear@0	39 return((int)(og->header[5]&0x02));
nuclear@0	40 }
nuclear@0	41
nuclear@0	42 int ogg_page_eos(const ogg_page *og){
nuclear@0	43 return((int)(og->header[5]&0x04));
nuclear@0	44 }
nuclear@0	45
nuclear@0	46 ogg_int64_t ogg_page_granulepos(const ogg_page *og){
nuclear@0	47 unsigned char *page=og->header;
nuclear@0	48 ogg_int64_t granulepos=page[13]&(0xff);
nuclear@0	49 granulepos= (granulepos<<8)\|(page[12]&0xff);
nuclear@0	50 granulepos= (granulepos<<8)\|(page[11]&0xff);
nuclear@0	51 granulepos= (granulepos<<8)\|(page[10]&0xff);
nuclear@0	52 granulepos= (granulepos<<8)\|(page[9]&0xff);
nuclear@0	53 granulepos= (granulepos<<8)\|(page[8]&0xff);
nuclear@0	54 granulepos= (granulepos<<8)\|(page[7]&0xff);
nuclear@0	55 granulepos= (granulepos<<8)\|(page[6]&0xff);
nuclear@0	56 return(granulepos);
nuclear@0	57 }
nuclear@0	58
nuclear@0	59 int ogg_page_serialno(const ogg_page *og){
nuclear@0	60 return(og->header[14] \|
nuclear@0	61 (og->header[15]<<8) \|
nuclear@0	62 (og->header[16]<<16) \|
nuclear@0	63 (og->header[17]<<24));
nuclear@0	64 }
nuclear@0	65
nuclear@0	66 long ogg_page_pageno(const ogg_page *og){
nuclear@0	67 return(og->header[18] \|
nuclear@0	68 (og->header[19]<<8) \|
nuclear@0	69 (og->header[20]<<16) \|
nuclear@0	70 (og->header[21]<<24));
nuclear@0	71 }
nuclear@0	72
nuclear@0	73
nuclear@0	74
nuclear@0	75 /* returns the number of packets that are completed on this page (if
nuclear@0	76 the leading packet is begun on a previous page, but ends on this
nuclear@0	77 page, it's counted */
nuclear@0	78
nuclear@0	79 /* NOTE:
nuclear@0	80 If a page consists of a packet begun on a previous page, and a new
nuclear@0	81 packet begun (but not completed) on this page, the return will be:
nuclear@0	82 ogg_page_packets(page) ==1,
nuclear@0	83 ogg_page_continued(page) !=0
nuclear@0	84
nuclear@0	85 If a page happens to be a single packet that was begun on a
nuclear@0	86 previous page, and spans to the next page (in the case of a three or
nuclear@0	87 more page packet), the return will be:
nuclear@0	88 ogg_page_packets(page) ==0,
nuclear@0	89 ogg_page_continued(page) !=0
nuclear@0	90 */
nuclear@0	91
nuclear@0	92 int ogg_page_packets(const ogg_page *og){
nuclear@0	93 int i,n=og->header[26],count=0;
nuclear@0	94 for(i=0;i<n;i++)
nuclear@0	95 if(og->header[27+i]<255)count++;
nuclear@0	96 return(count);
nuclear@0	97 }
nuclear@0	98
nuclear@0	99
nuclear@0	100 #if 0
nuclear@0	101 /* helper to initialize lookup for direct-table CRC (illustrative; we
nuclear@0	102 use the static init below) */
nuclear@0	103
nuclear@0	104 static ogg_uint32_t _ogg_crc_entry(unsigned long index){
nuclear@0	105 int i;
nuclear@0	106 unsigned long r;
nuclear@0	107
nuclear@0	108 r = index << 24;
nuclear@0	109 for (i=0; i<8; i++)
nuclear@0	110 if (r & 0x80000000UL)
nuclear@0	111 r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
nuclear@0	112 polynomial, although we use an
nuclear@0	113 unreflected alg and an init/final
nuclear@0	114 of 0, not 0xffffffff */
nuclear@0	115 else
nuclear@0	116 r<<=1;
nuclear@0	117 return (r & 0xffffffffUL);
nuclear@0	118 }
nuclear@0	119 #endif
nuclear@0	120
nuclear@0	121 static const ogg_uint32_t crc_lookup[256]={
nuclear@0	122 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
nuclear@0	123 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
nuclear@0	124 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
nuclear@0	125 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
nuclear@0	126 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
nuclear@0	127 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
nuclear@0	128 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
nuclear@0	129 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
nuclear@0	130 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
nuclear@0	131 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
nuclear@0	132 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
nuclear@0	133 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
nuclear@0	134 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
nuclear@0	135 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
nuclear@0	136 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
nuclear@0	137 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
nuclear@0	138 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
nuclear@0	139 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
nuclear@0	140 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
nuclear@0	141 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
nuclear@0	142 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
nuclear@0	143 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
nuclear@0	144 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
nuclear@0	145 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
nuclear@0	146 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
nuclear@0	147 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
nuclear@0	148 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
nuclear@0	149 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
nuclear@0	150 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
nuclear@0	151 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
nuclear@0	152 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
nuclear@0	153 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
nuclear@0	154 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
nuclear@0	155 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
nuclear@0	156 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
nuclear@0	157 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
nuclear@0	158 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
nuclear@0	159 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
nuclear@0	160 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
nuclear@0	161 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
nuclear@0	162 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
nuclear@0	163 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
nuclear@0	164 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
nuclear@0	165 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
nuclear@0	166 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
nuclear@0	167 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
nuclear@0	168 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
nuclear@0	169 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
nuclear@0	170 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
nuclear@0	171 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
nuclear@0	172 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
nuclear@0	173 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
nuclear@0	174 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
nuclear@0	175 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
nuclear@0	176 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
nuclear@0	177 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
nuclear@0	178 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
nuclear@0	179 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
nuclear@0	180 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
nuclear@0	181 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
nuclear@0	182 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
nuclear@0	183 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
nuclear@0	184 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
nuclear@0	185 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
nuclear@0	186
nuclear@0	187 /* init the encode/decode logical stream state */
nuclear@0	188
nuclear@0	189 int ogg_stream_init(ogg_stream_state *os,int serialno){
nuclear@0	190 if(os){
nuclear@0	191 memset(os,0,sizeof(*os));
nuclear@0	192 os->body_storage=16*1024;
nuclear@0	193 os->lacing_storage=1024;
nuclear@0	194
nuclear@0	195 os->body_data=_ogg_malloc(os->body_storagesizeof(os->body_data));
nuclear@0	196 os->lacing_vals=_ogg_malloc(os->lacing_storagesizeof(os->lacing_vals));
nuclear@0	197 os->granule_vals=_ogg_malloc(os->lacing_storagesizeof(os->granule_vals));
nuclear@0	198
nuclear@0	199 if(!os->body_data \|\| !os->lacing_vals \|\| !os->granule_vals){
nuclear@0	200 ogg_stream_clear(os);
nuclear@0	201 return -1;
nuclear@0	202 }
nuclear@0	203
nuclear@0	204 os->serialno=serialno;
nuclear@0	205
nuclear@0	206 return(0);
nuclear@0	207 }
nuclear@0	208 return(-1);
nuclear@0	209 }
nuclear@0	210
nuclear@0	211 /* async/delayed error detection for the ogg_stream_state */
nuclear@0	212 int ogg_stream_check(ogg_stream_state *os){
nuclear@0	213 if(!os \|\| !os->body_data) return -1;
nuclear@0	214 return 0;
nuclear@0	215 }
nuclear@0	216
nuclear@0	217 /* _clear does not free os, only the non-flat storage within */
nuclear@0	218 int ogg_stream_clear(ogg_stream_state *os){
nuclear@0	219 if(os){
nuclear@0	220 if(os->body_data)_ogg_free(os->body_data);
nuclear@0	221 if(os->lacing_vals)_ogg_free(os->lacing_vals);
nuclear@0	222 if(os->granule_vals)_ogg_free(os->granule_vals);
nuclear@0	223
nuclear@0	224 memset(os,0,sizeof(*os));
nuclear@0	225 }
nuclear@0	226 return(0);
nuclear@0	227 }
nuclear@0	228
nuclear@0	229 int ogg_stream_destroy(ogg_stream_state *os){
nuclear@0	230 if(os){
nuclear@0	231 ogg_stream_clear(os);
nuclear@0	232 _ogg_free(os);
nuclear@0	233 }
nuclear@0	234 return(0);
nuclear@0	235 }
nuclear@0	236
nuclear@0	237 /* Helpers for ogg_stream_encode; this keeps the structure and
nuclear@0	238 what's happening fairly clear */
nuclear@0	239
nuclear@0	240 static int _os_body_expand(ogg_stream_state *os,long needed){
nuclear@0	241 if(os->body_storage-needed<=os->body_fill){
nuclear@0	242 long body_storage;
nuclear@0	243 void *ret;
nuclear@0	244 if(os->body_storage>LONG_MAX-needed){
nuclear@0	245 ogg_stream_clear(os);
nuclear@0	246 return -1;
nuclear@0	247 }
nuclear@0	248 body_storage=os->body_storage+needed;
nuclear@0	249 if(body_storage<LONG_MAX-1024)body_storage+=1024;
nuclear@0	250 ret=_ogg_realloc(os->body_data,body_storagesizeof(os->body_data));
nuclear@0	251 if(!ret){
nuclear@0	252 ogg_stream_clear(os);
nuclear@0	253 return -1;
nuclear@0	254 }
nuclear@0	255 os->body_storage=body_storage;
nuclear@0	256 os->body_data=ret;
nuclear@0	257 }
nuclear@0	258 return 0;
nuclear@0	259 }
nuclear@0	260
nuclear@0	261 static int _os_lacing_expand(ogg_stream_state *os,long needed){
nuclear@0	262 if(os->lacing_storage-needed<=os->lacing_fill){
nuclear@0	263 long lacing_storage;
nuclear@0	264 void *ret;
nuclear@0	265 if(os->lacing_storage>LONG_MAX-needed){
nuclear@0	266 ogg_stream_clear(os);
nuclear@0	267 return -1;
nuclear@0	268 }
nuclear@0	269 lacing_storage=os->lacing_storage+needed;
nuclear@0	270 if(lacing_storage<LONG_MAX-32)lacing_storage+=32;
nuclear@0	271 ret=_ogg_realloc(os->lacing_vals,lacing_storagesizeof(os->lacing_vals));
nuclear@0	272 if(!ret){
nuclear@0	273 ogg_stream_clear(os);
nuclear@0	274 return -1;
nuclear@0	275 }
nuclear@0	276 os->lacing_vals=ret;
nuclear@0	277 ret=_ogg_realloc(os->granule_vals,lacing_storage*
nuclear@0	278 sizeof(*os->granule_vals));
nuclear@0	279 if(!ret){
nuclear@0	280 ogg_stream_clear(os);
nuclear@0	281 return -1;
nuclear@0	282 }
nuclear@0	283 os->granule_vals=ret;
nuclear@0	284 os->lacing_storage=lacing_storage;
nuclear@0	285 }
nuclear@0	286 return 0;
nuclear@0	287 }
nuclear@0	288
nuclear@0	289 /* checksum the page */
nuclear@0	290 /* Direct table CRC; note that this will be faster in the future if we
nuclear@0	291 perform the checksum simultaneously with other copies */
nuclear@0	292
nuclear@0	293 void ogg_page_checksum_set(ogg_page *og){
nuclear@0	294 if(og){
nuclear@0	295 ogg_uint32_t crc_reg=0;
nuclear@0	296 int i;
nuclear@0	297
nuclear@0	298 /* safety; needed for API behavior, but not framing code */
nuclear@0	299 og->header[22]=0;
nuclear@0	300 og->header[23]=0;
nuclear@0	301 og->header[24]=0;
nuclear@0	302 og->header[25]=0;
nuclear@0	303
nuclear@0	304 for(i=0;i<og->header_len;i++)
nuclear@0	305 crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
nuclear@0	306 for(i=0;i<og->body_len;i++)
nuclear@0	307 crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
nuclear@0	308
nuclear@0	309 og->header[22]=(unsigned char)(crc_reg&0xff);
nuclear@0	310 og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
nuclear@0	311 og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
nuclear@0	312 og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
nuclear@0	313 }
nuclear@0	314 }
nuclear@0	315
nuclear@0	316 /* submit data to the internal buffer of the framing engine */
nuclear@0	317 int ogg_stream_iovecin(ogg_stream_state os, ogg_iovec_t iov, int count,
nuclear@0	318 long e_o_s, ogg_int64_t granulepos){
nuclear@0	319
nuclear@0	320 long bytes = 0, lacing_vals;
nuclear@0	321 int i;
nuclear@0	322
nuclear@0	323 if(ogg_stream_check(os)) return -1;
nuclear@0	324 if(!iov) return 0;
nuclear@0	325
nuclear@0	326 for (i = 0; i < count; ++i){
nuclear@0	327 if(iov[i].iov_len>LONG_MAX) return -1;
nuclear@0	328 if(bytes>LONG_MAX-(long)iov[i].iov_len) return -1;
nuclear@0	329 bytes += (long)iov[i].iov_len;
nuclear@0	330 }
nuclear@0	331 lacing_vals=bytes/255+1;
nuclear@0	332
nuclear@0	333 if(os->body_returned){
nuclear@0	334 /* advance packet data according to the body_returned pointer. We
nuclear@0	335 had to keep it around to return a pointer into the buffer last
nuclear@0	336 call */
nuclear@0	337
nuclear@0	338 os->body_fill-=os->body_returned;
nuclear@0	339 if(os->body_fill)
nuclear@0	340 memmove(os->body_data,os->body_data+os->body_returned,
nuclear@0	341 os->body_fill);
nuclear@0	342 os->body_returned=0;
nuclear@0	343 }
nuclear@0	344
nuclear@0	345 /* make sure we have the buffer storage */
nuclear@0	346 if(_os_body_expand(os,bytes) \|\| _os_lacing_expand(os,lacing_vals))
nuclear@0	347 return -1;
nuclear@0	348
nuclear@0	349 /* Copy in the submitted packet. Yes, the copy is a waste; this is
nuclear@0	350 the liability of overly clean abstraction for the time being. It
nuclear@0	351 will actually be fairly easy to eliminate the extra copy in the
nuclear@0	352 future */
nuclear@0	353
nuclear@0	354 for (i = 0; i < count; ++i) {
nuclear@0	355 memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len);
nuclear@0	356 os->body_fill += (int)iov[i].iov_len;
nuclear@0	357 }
nuclear@0	358
nuclear@0	359 /* Store lacing vals for this packet */
nuclear@0	360 for(i=0;i<lacing_vals-1;i++){
nuclear@0	361 os->lacing_vals[os->lacing_fill+i]=255;
nuclear@0	362 os->granule_vals[os->lacing_fill+i]=os->granulepos;
nuclear@0	363 }
nuclear@0	364 os->lacing_vals[os->lacing_fill+i]=bytes%255;
nuclear@0	365 os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos;
nuclear@0	366
nuclear@0	367 /* flag the first segment as the beginning of the packet */
nuclear@0	368 os->lacing_vals[os->lacing_fill]\|= 0x100;
nuclear@0	369
nuclear@0	370 os->lacing_fill+=lacing_vals;
nuclear@0	371
nuclear@0	372 /* for the sake of completeness */
nuclear@0	373 os->packetno++;
nuclear@0	374
nuclear@0	375 if(e_o_s)os->e_o_s=1;
nuclear@0	376
nuclear@0	377 return(0);
nuclear@0	378 }
nuclear@0	379
nuclear@0	380 int ogg_stream_packetin(ogg_stream_state os,ogg_packet op){
nuclear@0	381 ogg_iovec_t iov;
nuclear@0	382 iov.iov_base = op->packet;
nuclear@0	383 iov.iov_len = op->bytes;
nuclear@0	384 return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos);
nuclear@0	385 }
nuclear@0	386
nuclear@0	387 /* Conditionally flush a page; force==0 will only flush nominal-size
nuclear@0	388 pages, force==1 forces us to flush a page regardless of page size
nuclear@0	389 so long as there's any data available at all. */
nuclear@0	390 static int ogg_stream_flush_i(ogg_stream_state os,ogg_page og, int force, int nfill){
nuclear@0	391 int i;
nuclear@0	392 int vals=0;
nuclear@0	393 int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
nuclear@0	394 int bytes=0;
nuclear@0	395 long acc=0;
nuclear@0	396 ogg_int64_t granule_pos=-1;
nuclear@0	397
nuclear@0	398 if(ogg_stream_check(os)) return(0);
nuclear@0	399 if(maxvals==0) return(0);
nuclear@0	400
nuclear@0	401 /* construct a page */
nuclear@0	402 /* decide how many segments to include */
nuclear@0	403
nuclear@0	404 /* If this is the initial header case, the first page must only include
nuclear@0	405 the initial header packet */
nuclear@0	406 if(os->b_o_s==0){ /* 'initial header page' case */
nuclear@0	407 granule_pos=0;
nuclear@0	408 for(vals=0;vals<maxvals;vals++){
nuclear@0	409 if((os->lacing_vals[vals]&0x0ff)<255){
nuclear@0	410 vals++;
nuclear@0	411 break;
nuclear@0	412 }
nuclear@0	413 }
nuclear@0	414 }else{
nuclear@0	415
nuclear@0	416 /* The extra packets_done, packet_just_done logic here attempts to do two things:
nuclear@0	417 1) Don't unneccessarily span pages.
nuclear@0	418 2) Unless necessary, don't flush pages if there are less than four packets on
nuclear@0	419 them; this expands page size to reduce unneccessary overhead if incoming packets
nuclear@0	420 are large.
nuclear@0	421 These are not necessary behaviors, just 'always better than naive flushing'
nuclear@0	422 without requiring an application to explicitly request a specific optimized
nuclear@0	423 behavior. We'll want an explicit behavior setup pathway eventually as well. */
nuclear@0	424
nuclear@0	425 int packets_done=0;
nuclear@0	426 int packet_just_done=0;
nuclear@0	427 for(vals=0;vals<maxvals;vals++){
nuclear@0	428 if(acc>nfill && packet_just_done>=4){
nuclear@0	429 force=1;
nuclear@0	430 break;
nuclear@0	431 }
nuclear@0	432 acc+=os->lacing_vals[vals]&0x0ff;
nuclear@0	433 if((os->lacing_vals[vals]&0xff)<255){
nuclear@0	434 granule_pos=os->granule_vals[vals];
nuclear@0	435 packet_just_done=++packets_done;
nuclear@0	436 }else
nuclear@0	437 packet_just_done=0;
nuclear@0	438 }
nuclear@0	439 if(vals==255)force=1;
nuclear@0	440 }
nuclear@0	441
nuclear@0	442 if(!force) return(0);
nuclear@0	443
nuclear@0	444 /* construct the header in temp storage */
nuclear@0	445 memcpy(os->header,"OggS",4);
nuclear@0	446
nuclear@0	447 /* stream structure version */
nuclear@0	448 os->header[4]=0x00;
nuclear@0	449
nuclear@0	450 /* continued packet flag? */
nuclear@0	451 os->header[5]=0x00;
nuclear@0	452 if((os->lacing_vals[0]&0x100)==0)os->header[5]\|=0x01;
nuclear@0	453 /* first page flag? */
nuclear@0	454 if(os->b_o_s==0)os->header[5]\|=0x02;
nuclear@0	455 /* last page flag? */
nuclear@0	456 if(os->e_o_s && os->lacing_fill==vals)os->header[5]\|=0x04;
nuclear@0	457 os->b_o_s=1;
nuclear@0	458
nuclear@0	459 /* 64 bits of PCM position */
nuclear@0	460 for(i=6;i<14;i++){
nuclear@0	461 os->header[i]=(unsigned char)(granule_pos&0xff);
nuclear@0	462 granule_pos>>=8;
nuclear@0	463 }
nuclear@0	464
nuclear@0	465 /* 32 bits of stream serial number */
nuclear@0	466 {
nuclear@0	467 long serialno=os->serialno;
nuclear@0	468 for(i=14;i<18;i++){
nuclear@0	469 os->header[i]=(unsigned char)(serialno&0xff);
nuclear@0	470 serialno>>=8;
nuclear@0	471 }
nuclear@0	472 }
nuclear@0	473
nuclear@0	474 /* 32 bits of page counter (we have both counter and page header
nuclear@0	475 because this val can roll over) */
nuclear@0	476 if(os->pageno==-1)os->pageno=0; /* because someone called
nuclear@0	477 stream_reset; this would be a
nuclear@0	478 strange thing to do in an
nuclear@0	479 encode stream, but it has
nuclear@0	480 plausible uses */
nuclear@0	481 {
nuclear@0	482 long pageno=os->pageno++;
nuclear@0	483 for(i=18;i<22;i++){
nuclear@0	484 os->header[i]=(unsigned char)(pageno&0xff);
nuclear@0	485 pageno>>=8;
nuclear@0	486 }
nuclear@0	487 }
nuclear@0	488
nuclear@0	489 /* zero for computation; filled in later */
nuclear@0	490 os->header[22]=0;
nuclear@0	491 os->header[23]=0;
nuclear@0	492 os->header[24]=0;
nuclear@0	493 os->header[25]=0;
nuclear@0	494
nuclear@0	495 /* segment table */
nuclear@0	496 os->header[26]=(unsigned char)(vals&0xff);
nuclear@0	497 for(i=0;i<vals;i++)
nuclear@0	498 bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);
nuclear@0	499
nuclear@0	500 /* set pointers in the ogg_page struct */
nuclear@0	501 og->header=os->header;
nuclear@0	502 og->header_len=os->header_fill=vals+27;
nuclear@0	503 og->body=os->body_data+os->body_returned;
nuclear@0	504 og->body_len=bytes;
nuclear@0	505
nuclear@0	506 /* advance the lacing data and set the body_returned pointer */
nuclear@0	507
nuclear@0	508 os->lacing_fill-=vals;
nuclear@0	509 memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fillsizeof(os->lacing_vals));
nuclear@0	510 memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fillsizeof(os->granule_vals));
nuclear@0	511 os->body_returned+=bytes;
nuclear@0	512
nuclear@0	513 /* calculate the checksum */
nuclear@0	514
nuclear@0	515 ogg_page_checksum_set(og);
nuclear@0	516
nuclear@0	517 /* done */
nuclear@0	518 return(1);
nuclear@0	519 }
nuclear@0	520
nuclear@0	521 /* This will flush remaining packets into a page (returning nonzero),
nuclear@0	522 even if there is not enough data to trigger a flush normally
nuclear@0	523 (undersized page). If there are no packets or partial packets to
nuclear@0	524 flush, ogg_stream_flush returns 0. Note that ogg_stream_flush will
nuclear@0	525 try to flush a normal sized page like ogg_stream_pageout; a call to
nuclear@0	526 ogg_stream_flush does not guarantee that all packets have flushed.
nuclear@0	527 Only a return value of 0 from ogg_stream_flush indicates all packet
nuclear@0	528 data is flushed into pages.
nuclear@0	529
nuclear@0	530 since ogg_stream_flush will flush the last page in a stream even if
nuclear@0	531 it's undersized, you almost certainly want to use ogg_stream_pageout
nuclear@0	532 (and not ogg_stream_flush) unless you specifically need to flush
nuclear@0	533 a page regardless of size in the middle of a stream. */
nuclear@0	534
nuclear@0	535 int ogg_stream_flush(ogg_stream_state os,ogg_page og){
nuclear@0	536 return ogg_stream_flush_i(os,og,1,4096);
nuclear@0	537 }
nuclear@0	538
nuclear@0	539 /* Like the above, but an argument is provided to adjust the nominal
nuclear@0	540 page size for applications which are smart enough to provide their
nuclear@0	541 own delay based flushing */
nuclear@0	542
nuclear@0	543 int ogg_stream_flush_fill(ogg_stream_state os,ogg_page og, int nfill){
nuclear@0	544 return ogg_stream_flush_i(os,og,1,nfill);
nuclear@0	545 }
nuclear@0	546
nuclear@0	547 /* This constructs pages from buffered packet segments. The pointers
nuclear@0	548 returned are to static buffers; do not free. The returned buffers are
nuclear@0	549 good only until the next call (using the same ogg_stream_state) */
nuclear@0	550
nuclear@0	551 int ogg_stream_pageout(ogg_stream_state os, ogg_page og){
nuclear@0	552 int force=0;
nuclear@0	553 if(ogg_stream_check(os)) return 0;
nuclear@0	554
nuclear@0	555 if((os->e_o_s&&os->lacing_fill) \|\| /* 'were done, now flush' case */
nuclear@0	556 (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */
nuclear@0	557 force=1;
nuclear@0	558
nuclear@0	559 return(ogg_stream_flush_i(os,og,force,4096));
nuclear@0	560 }
nuclear@0	561
nuclear@0	562 /* Like the above, but an argument is provided to adjust the nominal
nuclear@0	563 page size for applications which are smart enough to provide their
nuclear@0	564 own delay based flushing */
nuclear@0	565
nuclear@0	566 int ogg_stream_pageout_fill(ogg_stream_state os, ogg_page og, int nfill){
nuclear@0	567 int force=0;
nuclear@0	568 if(ogg_stream_check(os)) return 0;
nuclear@0	569
nuclear@0	570 if((os->e_o_s&&os->lacing_fill) \|\| /* 'were done, now flush' case */
nuclear@0	571 (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */
nuclear@0	572 force=1;
nuclear@0	573
nuclear@0	574 return(ogg_stream_flush_i(os,og,force,nfill));
nuclear@0	575 }
nuclear@0	576
nuclear@0	577 int ogg_stream_eos(ogg_stream_state *os){
nuclear@0	578 if(ogg_stream_check(os)) return 1;
nuclear@0	579 return os->e_o_s;
nuclear@0	580 }
nuclear@0	581
nuclear@0	582 /* DECODING PRIMITIVES: packet streaming layer **********************/
nuclear@0	583
nuclear@0	584 /* This has two layers to place more of the multi-serialno and paging
nuclear@0	585 control in the application's hands. First, we expose a data buffer
nuclear@0	586 using ogg_sync_buffer(). The app either copies into the
nuclear@0	587 buffer, or passes it directly to read(), etc. We then call
nuclear@0	588 ogg_sync_wrote() to tell how many bytes we just added.
nuclear@0	589
nuclear@0	590 Pages are returned (pointers into the buffer in ogg_sync_state)
nuclear@0	591 by ogg_sync_pageout(). The page is then submitted to
nuclear@0	592 ogg_stream_pagein() along with the appropriate
nuclear@0	593 ogg_stream_state* (ie, matching serialno). We then get raw
nuclear@0	594 packets out calling ogg_stream_packetout() with a
nuclear@0	595 ogg_stream_state. */
nuclear@0	596
nuclear@0	597 /* initialize the struct to a known state */
nuclear@0	598 int ogg_sync_init(ogg_sync_state *oy){
nuclear@0	599 if(oy){
nuclear@0	600 oy->storage = -1; /* used as a readiness flag */
nuclear@0	601 memset(oy,0,sizeof(*oy));
nuclear@0	602 }
nuclear@0	603 return(0);
nuclear@0	604 }
nuclear@0	605
nuclear@0	606 /* clear non-flat storage within */
nuclear@0	607 int ogg_sync_clear(ogg_sync_state *oy){
nuclear@0	608 if(oy){
nuclear@0	609 if(oy->data)_ogg_free(oy->data);
nuclear@0	610 memset(oy,0,sizeof(*oy));
nuclear@0	611 }
nuclear@0	612 return(0);
nuclear@0	613 }
nuclear@0	614
nuclear@0	615 int ogg_sync_destroy(ogg_sync_state *oy){
nuclear@0	616 if(oy){
nuclear@0	617 ogg_sync_clear(oy);
nuclear@0	618 _ogg_free(oy);
nuclear@0	619 }
nuclear@0	620 return(0);
nuclear@0	621 }
nuclear@0	622
nuclear@0	623 int ogg_sync_check(ogg_sync_state *oy){
nuclear@0	624 if(oy->storage<0) return -1;
nuclear@0	625 return 0;
nuclear@0	626 }
nuclear@0	627
nuclear@0	628 char ogg_sync_buffer(ogg_sync_state oy, long size){
nuclear@0	629 if(ogg_sync_check(oy)) return NULL;
nuclear@0	630
nuclear@0	631 /* first, clear out any space that has been previously returned */
nuclear@0	632 if(oy->returned){
nuclear@0	633 oy->fill-=oy->returned;
nuclear@0	634 if(oy->fill>0)
nuclear@0	635 memmove(oy->data,oy->data+oy->returned,oy->fill);
nuclear@0	636 oy->returned=0;
nuclear@0	637 }
nuclear@0	638
nuclear@0	639 if(size>oy->storage-oy->fill){
nuclear@0	640 /* We need to extend the internal buffer */
nuclear@0	641 long newsize=size+oy->fill+4096; /* an extra page to be nice */
nuclear@0	642 void *ret;
nuclear@0	643
nuclear@0	644 if(oy->data)
nuclear@0	645 ret=_ogg_realloc(oy->data,newsize);
nuclear@0	646 else
nuclear@0	647 ret=_ogg_malloc(newsize);
nuclear@0	648 if(!ret){
nuclear@0	649 ogg_sync_clear(oy);
nuclear@0	650 return NULL;
nuclear@0	651 }
nuclear@0	652 oy->data=ret;
nuclear@0	653 oy->storage=newsize;
nuclear@0	654 }
nuclear@0	655
nuclear@0	656 /* expose a segment at least as large as requested at the fill mark */
nuclear@0	657 return((char *)oy->data+oy->fill);
nuclear@0	658 }
nuclear@0	659
nuclear@0	660 int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
nuclear@0	661 if(ogg_sync_check(oy))return -1;
nuclear@0	662 if(oy->fill+bytes>oy->storage)return -1;
nuclear@0	663 oy->fill+=bytes;
nuclear@0	664 return(0);
nuclear@0	665 }
nuclear@0	666
nuclear@0	667 /* sync the stream. This is meant to be useful for finding page
nuclear@0	668 boundaries.
nuclear@0	669
nuclear@0	670 return values for this:
nuclear@0	671 -n) skipped n bytes
nuclear@0	672 0) page not ready; more data (no bytes skipped)
nuclear@0	673 n) page synced at current location; page length n bytes
nuclear@0	674
nuclear@0	675 */
nuclear@0	676
nuclear@0	677 long ogg_sync_pageseek(ogg_sync_state oy,ogg_page og){
nuclear@0	678 unsigned char *page=oy->data+oy->returned;
nuclear@0	679 unsigned char *next;
nuclear@0	680 long bytes=oy->fill-oy->returned;
nuclear@0	681
nuclear@0	682 if(ogg_sync_check(oy))return 0;
nuclear@0	683
nuclear@0	684 if(oy->headerbytes==0){
nuclear@0	685 int headerbytes,i;
nuclear@0	686 if(bytes<27)return(0); /* not enough for a header */
nuclear@0	687
nuclear@0	688 /* verify capture pattern */
nuclear@0	689 if(memcmp(page,"OggS",4))goto sync_fail;
nuclear@0	690
nuclear@0	691 headerbytes=page[26]+27;
nuclear@0	692 if(bytes<headerbytes)return(0); /* not enough for header + seg table */
nuclear@0	693
nuclear@0	694 /* count up body length in the segment table */
nuclear@0	695
nuclear@0	696 for(i=0;i<page[26];i++)
nuclear@0	697 oy->bodybytes+=page[27+i];
nuclear@0	698 oy->headerbytes=headerbytes;
nuclear@0	699 }
nuclear@0	700
nuclear@0	701 if(oy->bodybytes+oy->headerbytes>bytes)return(0);
nuclear@0	702
nuclear@0	703 /* The whole test page is buffered. Verify the checksum */
nuclear@0	704 {
nuclear@0	705 /* Grab the checksum bytes, set the header field to zero */
nuclear@0	706 char chksum[4];
nuclear@0	707 ogg_page log;
nuclear@0	708
nuclear@0	709 memcpy(chksum,page+22,4);
nuclear@0	710 memset(page+22,0,4);
nuclear@0	711
nuclear@0	712 /* set up a temp page struct and recompute the checksum */
nuclear@0	713 log.header=page;
nuclear@0	714 log.header_len=oy->headerbytes;
nuclear@0	715 log.body=page+oy->headerbytes;
nuclear@0	716 log.body_len=oy->bodybytes;
nuclear@0	717 ogg_page_checksum_set(&log);
nuclear@0	718
nuclear@0	719 /* Compare */
nuclear@0	720 if(memcmp(chksum,page+22,4)){
nuclear@0	721 /* D'oh. Mismatch! Corrupt page (or miscapture and not a page
nuclear@0	722 at all) */
nuclear@0	723 /* replace the computed checksum with the one actually read in */
nuclear@0	724 memcpy(page+22,chksum,4);
nuclear@0	725
nuclear@0	726 /* Bad checksum. Lose sync */
nuclear@0	727 goto sync_fail;
nuclear@0	728 }
nuclear@0	729 }
nuclear@0	730
nuclear@0	731 /* yes, have a whole page all ready to go */
nuclear@0	732 {
nuclear@0	733 unsigned char *page=oy->data+oy->returned;
nuclear@0	734 long bytes;
nuclear@0	735
nuclear@0	736 if(og){
nuclear@0	737 og->header=page;
nuclear@0	738 og->header_len=oy->headerbytes;
nuclear@0	739 og->body=page+oy->headerbytes;
nuclear@0	740 og->body_len=oy->bodybytes;
nuclear@0	741 }
nuclear@0	742
nuclear@0	743 oy->unsynced=0;
nuclear@0	744 oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
nuclear@0	745 oy->headerbytes=0;
nuclear@0	746 oy->bodybytes=0;
nuclear@0	747 return(bytes);
nuclear@0	748 }
nuclear@0	749
nuclear@0	750 sync_fail:
nuclear@0	751
nuclear@0	752 oy->headerbytes=0;
nuclear@0	753 oy->bodybytes=0;
nuclear@0	754
nuclear@0	755 /* search for possible capture */
nuclear@0	756 next=memchr(page+1,'O',bytes-1);
nuclear@0	757 if(!next)
nuclear@0	758 next=oy->data+oy->fill;
nuclear@0	759
nuclear@0	760 oy->returned=(int)(next-oy->data);
nuclear@0	761 return((long)-(next-page));
nuclear@0	762 }
nuclear@0	763
nuclear@0	764 /* sync the stream and get a page. Keep trying until we find a page.
nuclear@0	765 Suppress 'sync errors' after reporting the first.
nuclear@0	766
nuclear@0	767 return values:
nuclear@0	768 -1) recapture (hole in data)
nuclear@0	769 0) need more data
nuclear@0	770 1) page returned
nuclear@0	771
nuclear@0	772 Returns pointers into buffered data; invalidated by next call to
nuclear@0	773 _stream, _clear, _init, or _buffer */
nuclear@0	774
nuclear@0	775 int ogg_sync_pageout(ogg_sync_state oy, ogg_page og){
nuclear@0	776
nuclear@0	777 if(ogg_sync_check(oy))return 0;
nuclear@0	778
nuclear@0	779 /* all we need to do is verify a page at the head of the stream
nuclear@0	780 buffer. If it doesn't verify, we look for the next potential
nuclear@0	781 frame */
nuclear@0	782
nuclear@0	783 for(;;){
nuclear@0	784 long ret=ogg_sync_pageseek(oy,og);
nuclear@0	785 if(ret>0){
nuclear@0	786 /* have a page */
nuclear@0	787 return(1);
nuclear@0	788 }
nuclear@0	789 if(ret==0){
nuclear@0	790 /* need more data */
nuclear@0	791 return(0);
nuclear@0	792 }
nuclear@0	793
nuclear@0	794 /* head did not start a synced page... skipped some bytes */
nuclear@0	795 if(!oy->unsynced){
nuclear@0	796 oy->unsynced=1;
nuclear@0	797 return(-1);
nuclear@0	798 }
nuclear@0	799
nuclear@0	800 /* loop. keep looking */
nuclear@0	801
nuclear@0	802 }
nuclear@0	803 }
nuclear@0	804
nuclear@0	805 /* add the incoming page to the stream state; we decompose the page
nuclear@0	806 into packet segments here as well. */
nuclear@0	807
nuclear@0	808 int ogg_stream_pagein(ogg_stream_state os, ogg_page og){
nuclear@0	809 unsigned char *header=og->header;
nuclear@0	810 unsigned char *body=og->body;
nuclear@0	811 long bodysize=og->body_len;
nuclear@0	812 int segptr=0;
nuclear@0	813
nuclear@0	814 int version=ogg_page_version(og);
nuclear@0	815 int continued=ogg_page_continued(og);
nuclear@0	816 int bos=ogg_page_bos(og);
nuclear@0	817 int eos=ogg_page_eos(og);
nuclear@0	818 ogg_int64_t granulepos=ogg_page_granulepos(og);
nuclear@0	819 int serialno=ogg_page_serialno(og);
nuclear@0	820 long pageno=ogg_page_pageno(og);
nuclear@0	821 int segments=header[26];
nuclear@0	822
nuclear@0	823 if(ogg_stream_check(os)) return -1;
nuclear@0	824
nuclear@0	825 /* clean up 'returned data' */
nuclear@0	826 {
nuclear@0	827 long lr=os->lacing_returned;
nuclear@0	828 long br=os->body_returned;
nuclear@0	829
nuclear@0	830 /* body data */
nuclear@0	831 if(br){
nuclear@0	832 os->body_fill-=br;
nuclear@0	833 if(os->body_fill)
nuclear@0	834 memmove(os->body_data,os->body_data+br,os->body_fill);
nuclear@0	835 os->body_returned=0;
nuclear@0	836 }
nuclear@0	837
nuclear@0	838 if(lr){
nuclear@0	839 /* segment table */
nuclear@0	840 if(os->lacing_fill-lr){
nuclear@0	841 memmove(os->lacing_vals,os->lacing_vals+lr,
nuclear@0	842 (os->lacing_fill-lr)sizeof(os->lacing_vals));
nuclear@0	843 memmove(os->granule_vals,os->granule_vals+lr,
nuclear@0	844 (os->lacing_fill-lr)sizeof(os->granule_vals));
nuclear@0	845 }
nuclear@0	846 os->lacing_fill-=lr;
nuclear@0	847 os->lacing_packet-=lr;
nuclear@0	848 os->lacing_returned=0;
nuclear@0	849 }
nuclear@0	850 }
nuclear@0	851
nuclear@0	852 /* check the serial number */
nuclear@0	853 if(serialno!=os->serialno)return(-1);
nuclear@0	854 if(version>0)return(-1);
nuclear@0	855
nuclear@0	856 if(_os_lacing_expand(os,segments+1)) return -1;
nuclear@0	857
nuclear@0	858 /* are we in sequence? */
nuclear@0	859 if(pageno!=os->pageno){
nuclear@0	860 int i;
nuclear@0	861
nuclear@0	862 /* unroll previous partial packet (if any) */
nuclear@0	863 for(i=os->lacing_packet;i<os->lacing_fill;i++)
nuclear@0	864 os->body_fill-=os->lacing_vals[i]&0xff;
nuclear@0	865 os->lacing_fill=os->lacing_packet;
nuclear@0	866
nuclear@0	867 /* make a note of dropped data in segment table */
nuclear@0	868 if(os->pageno!=-1){
nuclear@0	869 os->lacing_vals[os->lacing_fill++]=0x400;
nuclear@0	870 os->lacing_packet++;
nuclear@0	871 }
nuclear@0	872 }
nuclear@0	873
nuclear@0	874 /* are we a 'continued packet' page? If so, we may need to skip
nuclear@0	875 some segments */
nuclear@0	876 if(continued){
nuclear@0	877 if(os->lacing_fill<1 \|\|
nuclear@0	878 os->lacing_vals[os->lacing_fill-1]==0x400){
nuclear@0	879 bos=0;
nuclear@0	880 for(;segptr<segments;segptr++){
nuclear@0	881 int val=header[27+segptr];
nuclear@0	882 body+=val;
nuclear@0	883 bodysize-=val;
nuclear@0	884 if(val<255){
nuclear@0	885 segptr++;
nuclear@0	886 break;
nuclear@0	887 }
nuclear@0	888 }
nuclear@0	889 }
nuclear@0	890 }
nuclear@0	891
nuclear@0	892 if(bodysize){
nuclear@0	893 if(_os_body_expand(os,bodysize)) return -1;
nuclear@0	894 memcpy(os->body_data+os->body_fill,body,bodysize);
nuclear@0	895 os->body_fill+=bodysize;
nuclear@0	896 }
nuclear@0	897
nuclear@0	898 {
nuclear@0	899 int saved=-1;
nuclear@0	900 while(segptr<segments){
nuclear@0	901 int val=header[27+segptr];
nuclear@0	902 os->lacing_vals[os->lacing_fill]=val;
nuclear@0	903 os->granule_vals[os->lacing_fill]=-1;
nuclear@0	904
nuclear@0	905 if(bos){
nuclear@0	906 os->lacing_vals[os->lacing_fill]\|=0x100;
nuclear@0	907 bos=0;
nuclear@0	908 }
nuclear@0	909
nuclear@0	910 if(val<255)saved=os->lacing_fill;
nuclear@0	911
nuclear@0	912 os->lacing_fill++;
nuclear@0	913 segptr++;
nuclear@0	914
nuclear@0	915 if(val<255)os->lacing_packet=os->lacing_fill;
nuclear@0	916 }
nuclear@0	917
nuclear@0	918 /* set the granulepos on the last granuleval of the last full packet */
nuclear@0	919 if(saved!=-1){
nuclear@0	920 os->granule_vals[saved]=granulepos;
nuclear@0	921 }
nuclear@0	922
nuclear@0	923 }
nuclear@0	924
nuclear@0	925 if(eos){
nuclear@0	926 os->e_o_s=1;
nuclear@0	927 if(os->lacing_fill>0)
nuclear@0	928 os->lacing_vals[os->lacing_fill-1]\|=0x200;
nuclear@0	929 }
nuclear@0	930
nuclear@0	931 os->pageno=pageno+1;
nuclear@0	932
nuclear@0	933 return(0);
nuclear@0	934 }
nuclear@0	935
nuclear@0	936 /* clear things to an initial state. Good to call, eg, before seeking */
nuclear@0	937 int ogg_sync_reset(ogg_sync_state *oy){
nuclear@0	938 if(ogg_sync_check(oy))return -1;
nuclear@0	939
nuclear@0	940 oy->fill=0;
nuclear@0	941 oy->returned=0;
nuclear@0	942 oy->unsynced=0;
nuclear@0	943 oy->headerbytes=0;
nuclear@0	944 oy->bodybytes=0;
nuclear@0	945 return(0);
nuclear@0	946 }
nuclear@0	947
nuclear@0	948 int ogg_stream_reset(ogg_stream_state *os){
nuclear@0	949 if(ogg_stream_check(os)) return -1;
nuclear@0	950
nuclear@0	951 os->body_fill=0;
nuclear@0	952 os->body_returned=0;
nuclear@0	953
nuclear@0	954 os->lacing_fill=0;
nuclear@0	955 os->lacing_packet=0;
nuclear@0	956 os->lacing_returned=0;
nuclear@0	957
nuclear@0	958 os->header_fill=0;
nuclear@0	959
nuclear@0	960 os->e_o_s=0;
nuclear@0	961 os->b_o_s=0;
nuclear@0	962 os->pageno=-1;
nuclear@0	963 os->packetno=0;
nuclear@0	964 os->granulepos=0;
nuclear@0	965
nuclear@0	966 return(0);
nuclear@0	967 }
nuclear@0	968
nuclear@0	969 int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
nuclear@0	970 if(ogg_stream_check(os)) return -1;
nuclear@0	971 ogg_stream_reset(os);
nuclear@0	972 os->serialno=serialno;
nuclear@0	973 return(0);
nuclear@0	974 }
nuclear@0	975
nuclear@0	976 static int _packetout(ogg_stream_state os,ogg_packet op,int adv){
nuclear@0	977
nuclear@0	978 /* The last part of decode. We have the stream broken into packet
nuclear@0	979 segments. Now we need to group them into packets (or return the
nuclear@0	980 out of sync markers) */
nuclear@0	981
nuclear@0	982 int ptr=os->lacing_returned;
nuclear@0	983
nuclear@0	984 if(os->lacing_packet<=ptr)return(0);
nuclear@0	985
nuclear@0	986 if(os->lacing_vals[ptr]&0x400){
nuclear@0	987 /* we need to tell the codec there's a gap; it might need to
nuclear@0	988 handle previous packet dependencies. */
nuclear@0	989 os->lacing_returned++;
nuclear@0	990 os->packetno++;
nuclear@0	991 return(-1);
nuclear@0	992 }
nuclear@0	993
nuclear@0	994 if(!op && !adv)return(1); /* just using peek as an inexpensive way
nuclear@0	995 to ask if there's a whole packet
nuclear@0	996 waiting */
nuclear@0	997
nuclear@0	998 /* Gather the whole packet. We'll have no holes or a partial packet */
nuclear@0	999 {
nuclear@0	1000 int size=os->lacing_vals[ptr]&0xff;
nuclear@0	1001 long bytes=size;
nuclear@0	1002 int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */
nuclear@0	1003 int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */
nuclear@0	1004
nuclear@0	1005 while(size==255){
nuclear@0	1006 int val=os->lacing_vals[++ptr];
nuclear@0	1007 size=val&0xff;
nuclear@0	1008 if(val&0x200)eos=0x200;
nuclear@0	1009 bytes+=size;
nuclear@0	1010 }
nuclear@0	1011
nuclear@0	1012 if(op){
nuclear@0	1013 op->e_o_s=eos;
nuclear@0	1014 op->b_o_s=bos;
nuclear@0	1015 op->packet=os->body_data+os->body_returned;
nuclear@0	1016 op->packetno=os->packetno;
nuclear@0	1017 op->granulepos=os->granule_vals[ptr];
nuclear@0	1018 op->bytes=bytes;
nuclear@0	1019 }
nuclear@0	1020
nuclear@0	1021 if(adv){
nuclear@0	1022 os->body_returned+=bytes;
nuclear@0	1023 os->lacing_returned=ptr+1;
nuclear@0	1024 os->packetno++;
nuclear@0	1025 }
nuclear@0	1026 }
nuclear@0	1027 return(1);
nuclear@0	1028 }
nuclear@0	1029
nuclear@0	1030 int ogg_stream_packetout(ogg_stream_state os,ogg_packet op){
nuclear@0	1031 if(ogg_stream_check(os)) return 0;
nuclear@0	1032 return _packetout(os,op,1);
nuclear@0	1033 }
nuclear@0	1034
nuclear@0	1035 int ogg_stream_packetpeek(ogg_stream_state os,ogg_packet op){
nuclear@0	1036 if(ogg_stream_check(os)) return 0;
nuclear@0	1037 return _packetout(os,op,0);
nuclear@0	1038 }
nuclear@0	1039
nuclear@0	1040 void ogg_packet_clear(ogg_packet *op) {
nuclear@0	1041 _ogg_free(op->packet);
nuclear@0	1042 memset(op, 0, sizeof(*op));
nuclear@0	1043 }
nuclear@0	1044
nuclear@0	1045 #ifdef _V_SELFTEST
nuclear@0	1046 #include <stdio.h>
nuclear@0	1047
nuclear@0	1048 ogg_stream_state os_en, os_de;
nuclear@0	1049 ogg_sync_state oy;
nuclear@0	1050
nuclear@0	1051 void checkpacket(ogg_packet *op,long len, int no, long pos){
nuclear@0	1052 long j;
nuclear@0	1053 static int sequence=0;
nuclear@0	1054 static int lastno=0;
nuclear@0	1055
nuclear@0	1056 if(op->bytes!=len){
nuclear@0	1057 fprintf(stderr,"incorrect packet length (%ld != %ld)!\n",op->bytes,len);
nuclear@0	1058 exit(1);
nuclear@0	1059 }
nuclear@0	1060 if(op->granulepos!=pos){
nuclear@0	1061 fprintf(stderr,"incorrect packet granpos (%ld != %ld)!\n",(long)op->granulepos,pos);
nuclear@0	1062 exit(1);
nuclear@0	1063 }
nuclear@0	1064
nuclear@0	1065 /* packet number just follows sequence/gap; adjust the input number
nuclear@0	1066 for that */
nuclear@0	1067 if(no==0){
nuclear@0	1068 sequence=0;
nuclear@0	1069 }else{
nuclear@0	1070 sequence++;
nuclear@0	1071 if(no>lastno+1)
nuclear@0	1072 sequence++;
nuclear@0	1073 }
nuclear@0	1074 lastno=no;
nuclear@0	1075 if(op->packetno!=sequence){
nuclear@0	1076 fprintf(stderr,"incorrect packet sequence %ld != %d\n",
nuclear@0	1077 (long)(op->packetno),sequence);
nuclear@0	1078 exit(1);
nuclear@0	1079 }
nuclear@0	1080
nuclear@0	1081 /* Test data */
nuclear@0	1082 for(j=0;j<op->bytes;j++)
nuclear@0	1083 if(op->packet[j]!=((j+no)&0xff)){
nuclear@0	1084 fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
nuclear@0	1085 j,op->packet[j],(j+no)&0xff);
nuclear@0	1086 exit(1);
nuclear@0	1087 }
nuclear@0	1088 }
nuclear@0	1089
nuclear@0	1090 void check_page(unsigned char data,const int header,ogg_page *og){
nuclear@0	1091 long j;
nuclear@0	1092 /* Test data */
nuclear@0	1093 for(j=0;j<og->body_len;j++)
nuclear@0	1094 if(og->body[j]!=data[j]){
nuclear@0	1095 fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
nuclear@0	1096 j,data[j],og->body[j]);
nuclear@0	1097 exit(1);
nuclear@0	1098 }
nuclear@0	1099
nuclear@0	1100 /* Test header */
nuclear@0	1101 for(j=0;j<og->header_len;j++){
nuclear@0	1102 if(og->header[j]!=header[j]){
nuclear@0	1103 fprintf(stderr,"header content mismatch at pos %ld:\n",j);
nuclear@0	1104 for(j=0;j<header[26]+27;j++)
nuclear@0	1105 fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
nuclear@0	1106 fprintf(stderr,"\n");
nuclear@0	1107 exit(1);
nuclear@0	1108 }
nuclear@0	1109 }
nuclear@0	1110 if(og->header_len!=header[26]+27){
nuclear@0	1111 fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
nuclear@0	1112 og->header_len,header[26]+27);
nuclear@0	1113 exit(1);
nuclear@0	1114 }
nuclear@0	1115 }
nuclear@0	1116
nuclear@0	1117 void print_header(ogg_page *og){
nuclear@0	1118 int j;
nuclear@0	1119 fprintf(stderr,"\nHEADER:\n");
nuclear@0	1120 fprintf(stderr," capture: %c %c %c %c version: %d flags: %x\n",
nuclear@0	1121 og->header[0],og->header[1],og->header[2],og->header[3],
nuclear@0	1122 (int)og->header[4],(int)og->header[5]);
nuclear@0	1123
nuclear@0	1124 fprintf(stderr," granulepos: %d serialno: %d pageno: %ld\n",
nuclear@0	1125 (og->header[9]<<24)\|(og->header[8]<<16)\|
nuclear@0	1126 (og->header[7]<<8)\|og->header[6],
nuclear@0	1127 (og->header[17]<<24)\|(og->header[16]<<16)\|
nuclear@0	1128 (og->header[15]<<8)\|og->header[14],
nuclear@0	1129 ((long)(og->header[21])<<24)\|(og->header[20]<<16)\|
nuclear@0	1130 (og->header[19]<<8)\|og->header[18]);
nuclear@0	1131
nuclear@0	1132 fprintf(stderr," checksum: %02x:%02x:%02x:%02x\n segments: %d (",
nuclear@0	1133 (int)og->header[22],(int)og->header[23],
nuclear@0	1134 (int)og->header[24],(int)og->header[25],
nuclear@0	1135 (int)og->header[26]);
nuclear@0	1136
nuclear@0	1137 for(j=27;j<og->header_len;j++)
nuclear@0	1138 fprintf(stderr,"%d ",(int)og->header[j]);
nuclear@0	1139 fprintf(stderr,")\n\n");
nuclear@0	1140 }
nuclear@0	1141
nuclear@0	1142 void copy_page(ogg_page *og){
nuclear@0	1143 unsigned char *temp=_ogg_malloc(og->header_len);
nuclear@0	1144 memcpy(temp,og->header,og->header_len);
nuclear@0	1145 og->header=temp;
nuclear@0	1146
nuclear@0	1147 temp=_ogg_malloc(og->body_len);
nuclear@0	1148 memcpy(temp,og->body,og->body_len);
nuclear@0	1149 og->body=temp;
nuclear@0	1150 }
nuclear@0	1151
nuclear@0	1152 void free_page(ogg_page *og){
nuclear@0	1153 _ogg_free (og->header);
nuclear@0	1154 _ogg_free (og->body);
nuclear@0	1155 }
nuclear@0	1156
nuclear@0	1157 void error(void){
nuclear@0	1158 fprintf(stderr,"error!\n");
nuclear@0	1159 exit(1);
nuclear@0	1160 }
nuclear@0	1161
nuclear@0	1162 /* 17 only */
nuclear@0	1163 const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
nuclear@0	1164 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1165 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1166 0x15,0xed,0xec,0x91,
nuclear@0	1167 1,
nuclear@0	1168 17};
nuclear@0	1169
nuclear@0	1170 /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
nuclear@0	1171 const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1172 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1173 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1174 0x59,0x10,0x6c,0x2c,
nuclear@0	1175 1,
nuclear@0	1176 17};
nuclear@0	1177 const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
nuclear@0	1178 0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1179 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1180 0x89,0x33,0x85,0xce,
nuclear@0	1181 13,
nuclear@0	1182 254,255,0,255,1,255,245,255,255,0,
nuclear@0	1183 255,255,90};
nuclear@0	1184
nuclear@0	1185 /* nil packets; beginning,middle,end */
nuclear@0	1186 const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1187 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1188 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1189 0xff,0x7b,0x23,0x17,
nuclear@0	1190 1,
nuclear@0	1191 0};
nuclear@0	1192 const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
nuclear@0	1193 0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1194 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1195 0x5c,0x3f,0x66,0xcb,
nuclear@0	1196 17,
nuclear@0	1197 17,254,255,0,0,255,1,0,255,245,255,255,0,
nuclear@0	1198 255,255,90,0};
nuclear@0	1199
nuclear@0	1200 /* large initial packet */
nuclear@0	1201 const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1202 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1203 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1204 0x01,0x27,0x31,0xaa,
nuclear@0	1205 18,
nuclear@0	1206 255,255,255,255,255,255,255,255,
nuclear@0	1207 255,255,255,255,255,255,255,255,255,10};
nuclear@0	1208
nuclear@0	1209 const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
nuclear@0	1210 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1211 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1212 0x7f,0x4e,0x8a,0xd2,
nuclear@0	1213 4,
nuclear@0	1214 255,4,255,0};
nuclear@0	1215
nuclear@0	1216
nuclear@0	1217 /* continuing packet test */
nuclear@0	1218 const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1219 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1220 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1221 0xff,0x7b,0x23,0x17,
nuclear@0	1222 1,
nuclear@0	1223 0};
nuclear@0	1224
nuclear@0	1225 const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
nuclear@0	1226 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
nuclear@0	1227 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1228 0xf8,0x3c,0x19,0x79,
nuclear@0	1229 255,
nuclear@0	1230 255,255,255,255,255,255,255,255,
nuclear@0	1231 255,255,255,255,255,255,255,255,
nuclear@0	1232 255,255,255,255,255,255,255,255,
nuclear@0	1233 255,255,255,255,255,255,255,255,
nuclear@0	1234 255,255,255,255,255,255,255,255,
nuclear@0	1235 255,255,255,255,255,255,255,255,
nuclear@0	1236 255,255,255,255,255,255,255,255,
nuclear@0	1237 255,255,255,255,255,255,255,255,
nuclear@0	1238 255,255,255,255,255,255,255,255,
nuclear@0	1239 255,255,255,255,255,255,255,255,
nuclear@0	1240 255,255,255,255,255,255,255,255,
nuclear@0	1241 255,255,255,255,255,255,255,255,
nuclear@0	1242 255,255,255,255,255,255,255,255,
nuclear@0	1243 255,255,255,255,255,255,255,255,
nuclear@0	1244 255,255,255,255,255,255,255,255,
nuclear@0	1245 255,255,255,255,255,255,255,255,
nuclear@0	1246 255,255,255,255,255,255,255,255,
nuclear@0	1247 255,255,255,255,255,255,255,255,
nuclear@0	1248 255,255,255,255,255,255,255,255,
nuclear@0	1249 255,255,255,255,255,255,255,255,
nuclear@0	1250 255,255,255,255,255,255,255,255,
nuclear@0	1251 255,255,255,255,255,255,255,255,
nuclear@0	1252 255,255,255,255,255,255,255,255,
nuclear@0	1253 255,255,255,255,255,255,255,255,
nuclear@0	1254 255,255,255,255,255,255,255,255,
nuclear@0	1255 255,255,255,255,255,255,255,255,
nuclear@0	1256 255,255,255,255,255,255,255,255,
nuclear@0	1257 255,255,255,255,255,255,255,255,
nuclear@0	1258 255,255,255,255,255,255,255,255,
nuclear@0	1259 255,255,255,255,255,255,255,255,
nuclear@0	1260 255,255,255,255,255,255,255,255,
nuclear@0	1261 255,255,255,255,255,255,255};
nuclear@0	1262
nuclear@0	1263 const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
nuclear@0	1264 0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1265 0x01,0x02,0x03,0x04,2,0,0,0,
nuclear@0	1266 0x38,0xe6,0xb6,0x28,
nuclear@0	1267 6,
nuclear@0	1268 255,220,255,4,255,0};
nuclear@0	1269
nuclear@0	1270
nuclear@0	1271 /* spill expansion test */
nuclear@0	1272 const int head1_4b[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1273 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1274 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1275 0xff,0x7b,0x23,0x17,
nuclear@0	1276 1,
nuclear@0	1277 0};
nuclear@0	1278
nuclear@0	1279 const int head2_4b[] = {0x4f,0x67,0x67,0x53,0,0x00,
nuclear@0	1280 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1281 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1282 0xce,0x8f,0x17,0x1a,
nuclear@0	1283 23,
nuclear@0	1284 255,255,255,255,255,255,255,255,
nuclear@0	1285 255,255,255,255,255,255,255,255,255,10,255,4,255,0,0};
nuclear@0	1286
nuclear@0	1287
nuclear@0	1288 const int head3_4b[] = {0x4f,0x67,0x67,0x53,0,0x04,
nuclear@0	1289 0x07,0x14,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1290 0x01,0x02,0x03,0x04,2,0,0,0,
nuclear@0	1291 0x9b,0xb2,0x50,0xa1,
nuclear@0	1292 1,
nuclear@0	1293 0};
nuclear@0	1294
nuclear@0	1295 /* page with the 255 segment limit */
nuclear@0	1296 const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1297 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1298 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1299 0xff,0x7b,0x23,0x17,
nuclear@0	1300 1,
nuclear@0	1301 0};
nuclear@0	1302
nuclear@0	1303 const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
nuclear@0	1304 0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1305 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1306 0xed,0x2a,0x2e,0xa7,
nuclear@0	1307 255,
nuclear@0	1308 10,10,10,10,10,10,10,10,
nuclear@0	1309 10,10,10,10,10,10,10,10,
nuclear@0	1310 10,10,10,10,10,10,10,10,
nuclear@0	1311 10,10,10,10,10,10,10,10,
nuclear@0	1312 10,10,10,10,10,10,10,10,
nuclear@0	1313 10,10,10,10,10,10,10,10,
nuclear@0	1314 10,10,10,10,10,10,10,10,
nuclear@0	1315 10,10,10,10,10,10,10,10,
nuclear@0	1316 10,10,10,10,10,10,10,10,
nuclear@0	1317 10,10,10,10,10,10,10,10,
nuclear@0	1318 10,10,10,10,10,10,10,10,
nuclear@0	1319 10,10,10,10,10,10,10,10,
nuclear@0	1320 10,10,10,10,10,10,10,10,
nuclear@0	1321 10,10,10,10,10,10,10,10,
nuclear@0	1322 10,10,10,10,10,10,10,10,
nuclear@0	1323 10,10,10,10,10,10,10,10,
nuclear@0	1324 10,10,10,10,10,10,10,10,
nuclear@0	1325 10,10,10,10,10,10,10,10,
nuclear@0	1326 10,10,10,10,10,10,10,10,
nuclear@0	1327 10,10,10,10,10,10,10,10,
nuclear@0	1328 10,10,10,10,10,10,10,10,
nuclear@0	1329 10,10,10,10,10,10,10,10,
nuclear@0	1330 10,10,10,10,10,10,10,10,
nuclear@0	1331 10,10,10,10,10,10,10,10,
nuclear@0	1332 10,10,10,10,10,10,10,10,
nuclear@0	1333 10,10,10,10,10,10,10,10,
nuclear@0	1334 10,10,10,10,10,10,10,10,
nuclear@0	1335 10,10,10,10,10,10,10,10,
nuclear@0	1336 10,10,10,10,10,10,10,10,
nuclear@0	1337 10,10,10,10,10,10,10,10,
nuclear@0	1338 10,10,10,10,10,10,10,10,
nuclear@0	1339 10,10,10,10,10,10,10};
nuclear@0	1340
nuclear@0	1341 const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
nuclear@0	1342 0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1343 0x01,0x02,0x03,0x04,2,0,0,0,
nuclear@0	1344 0x6c,0x3b,0x82,0x3d,
nuclear@0	1345 1,
nuclear@0	1346 50};
nuclear@0	1347
nuclear@0	1348
nuclear@0	1349 /* packet that overspans over an entire page */
nuclear@0	1350 const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1351 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1352 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1353 0xff,0x7b,0x23,0x17,
nuclear@0	1354 1,
nuclear@0	1355 0};
nuclear@0	1356
nuclear@0	1357 const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
nuclear@0	1358 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1359 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1360 0x68,0x22,0x7c,0x3d,
nuclear@0	1361 255,
nuclear@0	1362 100,
nuclear@0	1363 255,255,255,255,255,255,255,255,
nuclear@0	1364 255,255,255,255,255,255,255,255,
nuclear@0	1365 255,255,255,255,255,255,255,255,
nuclear@0	1366 255,255,255,255,255,255,255,255,
nuclear@0	1367 255,255,255,255,255,255,255,255,
nuclear@0	1368 255,255,255,255,255,255,255,255,
nuclear@0	1369 255,255,255,255,255,255,255,255,
nuclear@0	1370 255,255,255,255,255,255,255,255,
nuclear@0	1371 255,255,255,255,255,255,255,255,
nuclear@0	1372 255,255,255,255,255,255,255,255,
nuclear@0	1373 255,255,255,255,255,255,255,255,
nuclear@0	1374 255,255,255,255,255,255,255,255,
nuclear@0	1375 255,255,255,255,255,255,255,255,
nuclear@0	1376 255,255,255,255,255,255,255,255,
nuclear@0	1377 255,255,255,255,255,255,255,255,
nuclear@0	1378 255,255,255,255,255,255,255,255,
nuclear@0	1379 255,255,255,255,255,255,255,255,
nuclear@0	1380 255,255,255,255,255,255,255,255,
nuclear@0	1381 255,255,255,255,255,255,255,255,
nuclear@0	1382 255,255,255,255,255,255,255,255,
nuclear@0	1383 255,255,255,255,255,255,255,255,
nuclear@0	1384 255,255,255,255,255,255,255,255,
nuclear@0	1385 255,255,255,255,255,255,255,255,
nuclear@0	1386 255,255,255,255,255,255,255,255,
nuclear@0	1387 255,255,255,255,255,255,255,255,
nuclear@0	1388 255,255,255,255,255,255,255,255,
nuclear@0	1389 255,255,255,255,255,255,255,255,
nuclear@0	1390 255,255,255,255,255,255,255,255,
nuclear@0	1391 255,255,255,255,255,255,255,255,
nuclear@0	1392 255,255,255,255,255,255,255,255,
nuclear@0	1393 255,255,255,255,255,255,255,255,
nuclear@0	1394 255,255,255,255,255,255};
nuclear@0	1395
nuclear@0	1396 const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
nuclear@0	1397 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
nuclear@0	1398 0x01,0x02,0x03,0x04,2,0,0,0,
nuclear@0	1399 0xf4,0x87,0xba,0xf3,
nuclear@0	1400 255,
nuclear@0	1401 255,255,255,255,255,255,255,255,
nuclear@0	1402 255,255,255,255,255,255,255,255,
nuclear@0	1403 255,255,255,255,255,255,255,255,
nuclear@0	1404 255,255,255,255,255,255,255,255,
nuclear@0	1405 255,255,255,255,255,255,255,255,
nuclear@0	1406 255,255,255,255,255,255,255,255,
nuclear@0	1407 255,255,255,255,255,255,255,255,
nuclear@0	1408 255,255,255,255,255,255,255,255,
nuclear@0	1409 255,255,255,255,255,255,255,255,
nuclear@0	1410 255,255,255,255,255,255,255,255,
nuclear@0	1411 255,255,255,255,255,255,255,255,
nuclear@0	1412 255,255,255,255,255,255,255,255,
nuclear@0	1413 255,255,255,255,255,255,255,255,
nuclear@0	1414 255,255,255,255,255,255,255,255,
nuclear@0	1415 255,255,255,255,255,255,255,255,
nuclear@0	1416 255,255,255,255,255,255,255,255,
nuclear@0	1417 255,255,255,255,255,255,255,255,
nuclear@0	1418 255,255,255,255,255,255,255,255,
nuclear@0	1419 255,255,255,255,255,255,255,255,
nuclear@0	1420 255,255,255,255,255,255,255,255,
nuclear@0	1421 255,255,255,255,255,255,255,255,
nuclear@0	1422 255,255,255,255,255,255,255,255,
nuclear@0	1423 255,255,255,255,255,255,255,255,
nuclear@0	1424 255,255,255,255,255,255,255,255,
nuclear@0	1425 255,255,255,255,255,255,255,255,
nuclear@0	1426 255,255,255,255,255,255,255,255,
nuclear@0	1427 255,255,255,255,255,255,255,255,
nuclear@0	1428 255,255,255,255,255,255,255,255,
nuclear@0	1429 255,255,255,255,255,255,255,255,
nuclear@0	1430 255,255,255,255,255,255,255,255,
nuclear@0	1431 255,255,255,255,255,255,255,255,
nuclear@0	1432 255,255,255,255,255,255,255};
nuclear@0	1433
nuclear@0	1434 const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
nuclear@0	1435 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1436 0x01,0x02,0x03,0x04,3,0,0,0,
nuclear@0	1437 0xf7,0x2f,0x6c,0x60,
nuclear@0	1438 5,
nuclear@0	1439 254,255,4,255,0};
nuclear@0	1440
nuclear@0	1441 /* packet that overspans over an entire page */
nuclear@0	1442 const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
nuclear@0	1443 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1444 0x01,0x02,0x03,0x04,0,0,0,0,
nuclear@0	1445 0xff,0x7b,0x23,0x17,
nuclear@0	1446 1,
nuclear@0	1447 0};
nuclear@0	1448
nuclear@0	1449 const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
nuclear@0	1450 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1451 0x01,0x02,0x03,0x04,1,0,0,0,
nuclear@0	1452 0x68,0x22,0x7c,0x3d,
nuclear@0	1453 255,
nuclear@0	1454 100,
nuclear@0	1455 255,255,255,255,255,255,255,255,
nuclear@0	1456 255,255,255,255,255,255,255,255,
nuclear@0	1457 255,255,255,255,255,255,255,255,
nuclear@0	1458 255,255,255,255,255,255,255,255,
nuclear@0	1459 255,255,255,255,255,255,255,255,
nuclear@0	1460 255,255,255,255,255,255,255,255,
nuclear@0	1461 255,255,255,255,255,255,255,255,
nuclear@0	1462 255,255,255,255,255,255,255,255,
nuclear@0	1463 255,255,255,255,255,255,255,255,
nuclear@0	1464 255,255,255,255,255,255,255,255,
nuclear@0	1465 255,255,255,255,255,255,255,255,
nuclear@0	1466 255,255,255,255,255,255,255,255,
nuclear@0	1467 255,255,255,255,255,255,255,255,
nuclear@0	1468 255,255,255,255,255,255,255,255,
nuclear@0	1469 255,255,255,255,255,255,255,255,
nuclear@0	1470 255,255,255,255,255,255,255,255,
nuclear@0	1471 255,255,255,255,255,255,255,255,
nuclear@0	1472 255,255,255,255,255,255,255,255,
nuclear@0	1473 255,255,255,255,255,255,255,255,
nuclear@0	1474 255,255,255,255,255,255,255,255,
nuclear@0	1475 255,255,255,255,255,255,255,255,
nuclear@0	1476 255,255,255,255,255,255,255,255,
nuclear@0	1477 255,255,255,255,255,255,255,255,
nuclear@0	1478 255,255,255,255,255,255,255,255,
nuclear@0	1479 255,255,255,255,255,255,255,255,
nuclear@0	1480 255,255,255,255,255,255,255,255,
nuclear@0	1481 255,255,255,255,255,255,255,255,
nuclear@0	1482 255,255,255,255,255,255,255,255,
nuclear@0	1483 255,255,255,255,255,255,255,255,
nuclear@0	1484 255,255,255,255,255,255,255,255,
nuclear@0	1485 255,255,255,255,255,255,255,255,
nuclear@0	1486 255,255,255,255,255,255};
nuclear@0	1487
nuclear@0	1488 const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
nuclear@0	1489 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
nuclear@0	1490 0x01,0x02,0x03,0x04,2,0,0,0,
nuclear@0	1491 0xd4,0xe0,0x60,0xe5,
nuclear@0	1492 1,
nuclear@0	1493 0};
nuclear@0	1494
nuclear@0	1495 void test_pack(const int pl, const int *headers, int byteskip,
nuclear@0	1496 int pageskip, int packetskip){
nuclear@0	1497 unsigned char data=_ogg_malloc(10241024); /* for scripted test cases only */
nuclear@0	1498 long inptr=0;
nuclear@0	1499 long outptr=0;
nuclear@0	1500 long deptr=0;
nuclear@0	1501 long depacket=0;
nuclear@0	1502 long granule_pos=7,pageno=0;
nuclear@0	1503 int i,j,packets,pageout=pageskip;
nuclear@0	1504 int eosflag=0;
nuclear@0	1505 int bosflag=0;
nuclear@0	1506
nuclear@0	1507 int byteskipcount=0;
nuclear@0	1508
nuclear@0	1509 ogg_stream_reset(&os_en);
nuclear@0	1510 ogg_stream_reset(&os_de);
nuclear@0	1511 ogg_sync_reset(&oy);
nuclear@0	1512
nuclear@0	1513 for(packets=0;packets<packetskip;packets++)
nuclear@0	1514 depacket+=pl[packets];
nuclear@0	1515
nuclear@0	1516 for(packets=0;;packets++)if(pl[packets]==-1)break;
nuclear@0	1517
nuclear@0	1518 for(i=0;i<packets;i++){
nuclear@0	1519 /* construct a test packet */
nuclear@0	1520 ogg_packet op;
nuclear@0	1521 int len=pl[i];
nuclear@0	1522
nuclear@0	1523 op.packet=data+inptr;
nuclear@0	1524 op.bytes=len;
nuclear@0	1525 op.e_o_s=(pl[i+1]<0?1:0);
nuclear@0	1526 op.granulepos=granule_pos;
nuclear@0	1527
nuclear@0	1528 granule_pos+=1024;
nuclear@0	1529
nuclear@0	1530 for(j=0;j<len;j++)data[inptr++]=i+j;
nuclear@0	1531
nuclear@0	1532 /* submit the test packet */
nuclear@0	1533 ogg_stream_packetin(&os_en,&op);
nuclear@0	1534
nuclear@0	1535 /* retrieve any finished pages */
nuclear@0	1536 {
nuclear@0	1537 ogg_page og;
nuclear@0	1538
nuclear@0	1539 while(ogg_stream_pageout(&os_en,&og)){
nuclear@0	1540 /* We have a page. Check it carefully */
nuclear@0	1541
nuclear@0	1542 fprintf(stderr,"%ld, ",pageno);
nuclear@0	1543
nuclear@0	1544 if(headers[pageno]==NULL){
nuclear@0	1545 fprintf(stderr,"coded too many pages!\n");
nuclear@0	1546 exit(1);
nuclear@0	1547 }
nuclear@0	1548
nuclear@0	1549 check_page(data+outptr,headers[pageno],&og);
nuclear@0	1550
nuclear@0	1551 outptr+=og.body_len;
nuclear@0	1552 pageno++;
nuclear@0	1553 if(pageskip){
nuclear@0	1554 bosflag=1;
nuclear@0	1555 pageskip--;
nuclear@0	1556 deptr+=og.body_len;
nuclear@0	1557 }
nuclear@0	1558
nuclear@0	1559 /* have a complete page; submit it to sync/decode */
nuclear@0	1560
nuclear@0	1561 {
nuclear@0	1562 ogg_page og_de;
nuclear@0	1563 ogg_packet op_de,op_de2;
nuclear@0	1564 char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
nuclear@0	1565 char *next=buf;
nuclear@0	1566 byteskipcount+=og.header_len;
nuclear@0	1567 if(byteskipcount>byteskip){
nuclear@0	1568 memcpy(next,og.header,byteskipcount-byteskip);
nuclear@0	1569 next+=byteskipcount-byteskip;
nuclear@0	1570 byteskipcount=byteskip;
nuclear@0	1571 }
nuclear@0	1572
nuclear@0	1573 byteskipcount+=og.body_len;
nuclear@0	1574 if(byteskipcount>byteskip){
nuclear@0	1575 memcpy(next,og.body,byteskipcount-byteskip);
nuclear@0	1576 next+=byteskipcount-byteskip;
nuclear@0	1577 byteskipcount=byteskip;
nuclear@0	1578 }
nuclear@0	1579
nuclear@0	1580 ogg_sync_wrote(&oy,next-buf);
nuclear@0	1581
nuclear@0	1582 while(1){
nuclear@0	1583 int ret=ogg_sync_pageout(&oy,&og_de);
nuclear@0	1584 if(ret==0)break;
nuclear@0	1585 if(ret<0)continue;
nuclear@0	1586 /* got a page. Happy happy. Verify that it's good. */
nuclear@0	1587
nuclear@0	1588 fprintf(stderr,"(%d), ",pageout);
nuclear@0	1589
nuclear@0	1590 check_page(data+deptr,headers[pageout],&og_de);
nuclear@0	1591 deptr+=og_de.body_len;
nuclear@0	1592 pageout++;
nuclear@0	1593
nuclear@0	1594 /* submit it to deconstitution */
nuclear@0	1595 ogg_stream_pagein(&os_de,&og_de);
nuclear@0	1596
nuclear@0	1597 /* packets out? */
nuclear@0	1598 while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
nuclear@0	1599 ogg_stream_packetpeek(&os_de,NULL);
nuclear@0	1600 ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
nuclear@0	1601
nuclear@0	1602 /* verify peek and out match */
nuclear@0	1603 if(memcmp(&op_de,&op_de2,sizeof(op_de))){
nuclear@0	1604 fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
nuclear@0	1605 depacket);
nuclear@0	1606 exit(1);
nuclear@0	1607 }
nuclear@0	1608
nuclear@0	1609 /* verify the packet! */
nuclear@0	1610 /* check data */
nuclear@0	1611 if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
nuclear@0	1612 fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
nuclear@0	1613 depacket);
nuclear@0	1614 exit(1);
nuclear@0	1615 }
nuclear@0	1616 /* check bos flag */
nuclear@0	1617 if(bosflag==0 && op_de.b_o_s==0){
nuclear@0	1618 fprintf(stderr,"b_o_s flag not set on packet!\n");
nuclear@0	1619 exit(1);
nuclear@0	1620 }
nuclear@0	1621 if(bosflag && op_de.b_o_s){
nuclear@0	1622 fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
nuclear@0	1623 exit(1);
nuclear@0	1624 }
nuclear@0	1625 bosflag=1;
nuclear@0	1626 depacket+=op_de.bytes;
nuclear@0	1627
nuclear@0	1628 /* check eos flag */
nuclear@0	1629 if(eosflag){
nuclear@0	1630 fprintf(stderr,"Multiple decoded packets with eos flag!\n");
nuclear@0	1631 exit(1);
nuclear@0	1632 }
nuclear@0	1633
nuclear@0	1634 if(op_de.e_o_s)eosflag=1;
nuclear@0	1635
nuclear@0	1636 /* check granulepos flag */
nuclear@0	1637 if(op_de.granulepos!=-1){
nuclear@0	1638 fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
nuclear@0	1639 }
nuclear@0	1640 }
nuclear@0	1641 }
nuclear@0	1642 }
nuclear@0	1643 }
nuclear@0	1644 }
nuclear@0	1645 }
nuclear@0	1646 _ogg_free(data);
nuclear@0	1647 if(headers[pageno]!=NULL){
nuclear@0	1648 fprintf(stderr,"did not write last page!\n");
nuclear@0	1649 exit(1);
nuclear@0	1650 }
nuclear@0	1651 if(headers[pageout]!=NULL){
nuclear@0	1652 fprintf(stderr,"did not decode last page!\n");
nuclear@0	1653 exit(1);
nuclear@0	1654 }
nuclear@0	1655 if(inptr!=outptr){
nuclear@0	1656 fprintf(stderr,"encoded page data incomplete!\n");
nuclear@0	1657 exit(1);
nuclear@0	1658 }
nuclear@0	1659 if(inptr!=deptr){
nuclear@0	1660 fprintf(stderr,"decoded page data incomplete!\n");
nuclear@0	1661 exit(1);
nuclear@0	1662 }
nuclear@0	1663 if(inptr!=depacket){
nuclear@0	1664 fprintf(stderr,"decoded packet data incomplete!\n");
nuclear@0	1665 exit(1);
nuclear@0	1666 }
nuclear@0	1667 if(!eosflag){
nuclear@0	1668 fprintf(stderr,"Never got a packet with EOS set!\n");
nuclear@0	1669 exit(1);
nuclear@0	1670 }
nuclear@0	1671 fprintf(stderr,"ok.\n");
nuclear@0	1672 }
nuclear@0	1673
nuclear@0	1674 int main(void){
nuclear@0	1675
nuclear@0	1676 ogg_stream_init(&os_en,0x04030201);
nuclear@0	1677 ogg_stream_init(&os_de,0x04030201);
nuclear@0	1678 ogg_sync_init(&oy);
nuclear@0	1679
nuclear@0	1680 /* Exercise each code path in the framing code. Also verify that
nuclear@0	1681 the checksums are working. */
nuclear@0	1682
nuclear@0	1683 {
nuclear@0	1684 /* 17 only */
nuclear@0	1685 const int packets[]={17, -1};
nuclear@0	1686 const int *headret[]={head1_0,NULL};
nuclear@0	1687
nuclear@0	1688 fprintf(stderr,"testing single page encoding... ");
nuclear@0	1689 test_pack(packets,headret,0,0,0);
nuclear@0	1690 }
nuclear@0	1691
nuclear@0	1692 {
nuclear@0	1693 /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
nuclear@0	1694 const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};
nuclear@0	1695 const int *headret[]={head1_1,head2_1,NULL};
nuclear@0	1696
nuclear@0	1697 fprintf(stderr,"testing basic page encoding... ");
nuclear@0	1698 test_pack(packets,headret,0,0,0);
nuclear@0	1699 }
nuclear@0	1700
nuclear@0	1701 {
nuclear@0	1702 /* nil packets; beginning,middle,end */
nuclear@0	1703 const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};
nuclear@0	1704 const int *headret[]={head1_2,head2_2,NULL};
nuclear@0	1705
nuclear@0	1706 fprintf(stderr,"testing basic nil packets... ");
nuclear@0	1707 test_pack(packets,headret,0,0,0);
nuclear@0	1708 }
nuclear@0	1709
nuclear@0	1710 {
nuclear@0	1711 /* large initial packet */
nuclear@0	1712 const int packets[]={4345,259,255,-1};
nuclear@0	1713 const int *headret[]={head1_3,head2_3,NULL};
nuclear@0	1714
nuclear@0	1715 fprintf(stderr,"testing initial-packet lacing > 4k... ");
nuclear@0	1716 test_pack(packets,headret,0,0,0);
nuclear@0	1717 }
nuclear@0	1718
nuclear@0	1719 {
nuclear@0	1720 /* continuing packet test; with page spill expansion, we have to
nuclear@0	1721 overflow the lacing table. */
nuclear@0	1722 const int packets[]={0,65500,259,255,-1};
nuclear@0	1723 const int *headret[]={head1_4,head2_4,head3_4,NULL};
nuclear@0	1724
nuclear@0	1725 fprintf(stderr,"testing single packet page span... ");
nuclear@0	1726 test_pack(packets,headret,0,0,0);
nuclear@0	1727 }
nuclear@0	1728
nuclear@0	1729 {
nuclear@0	1730 /* spill expand packet test */
nuclear@0	1731 const int packets[]={0,4345,259,255,0,0,-1};
nuclear@0	1732 const int *headret[]={head1_4b,head2_4b,head3_4b,NULL};
nuclear@0	1733
nuclear@0	1734 fprintf(stderr,"testing page spill expansion... ");
nuclear@0	1735 test_pack(packets,headret,0,0,0);
nuclear@0	1736 }
nuclear@0	1737
nuclear@0	1738 /* page with the 255 segment limit */
nuclear@0	1739 {
nuclear@0	1740
nuclear@0	1741 const int packets[]={0,10,10,10,10,10,10,10,10,
nuclear@0	1742 10,10,10,10,10,10,10,10,
nuclear@0	1743 10,10,10,10,10,10,10,10,
nuclear@0	1744 10,10,10,10,10,10,10,10,
nuclear@0	1745 10,10,10,10,10,10,10,10,
nuclear@0	1746 10,10,10,10,10,10,10,10,
nuclear@0	1747 10,10,10,10,10,10,10,10,
nuclear@0	1748 10,10,10,10,10,10,10,10,
nuclear@0	1749 10,10,10,10,10,10,10,10,
nuclear@0	1750 10,10,10,10,10,10,10,10,
nuclear@0	1751 10,10,10,10,10,10,10,10,
nuclear@0	1752 10,10,10,10,10,10,10,10,
nuclear@0	1753 10,10,10,10,10,10,10,10,
nuclear@0	1754 10,10,10,10,10,10,10,10,
nuclear@0	1755 10,10,10,10,10,10,10,10,
nuclear@0	1756 10,10,10,10,10,10,10,10,
nuclear@0	1757 10,10,10,10,10,10,10,10,
nuclear@0	1758 10,10,10,10,10,10,10,10,
nuclear@0	1759 10,10,10,10,10,10,10,10,
nuclear@0	1760 10,10,10,10,10,10,10,10,
nuclear@0	1761 10,10,10,10,10,10,10,10,
nuclear@0	1762 10,10,10,10,10,10,10,10,
nuclear@0	1763 10,10,10,10,10,10,10,10,
nuclear@0	1764 10,10,10,10,10,10,10,10,
nuclear@0	1765 10,10,10,10,10,10,10,10,
nuclear@0	1766 10,10,10,10,10,10,10,10,
nuclear@0	1767 10,10,10,10,10,10,10,10,
nuclear@0	1768 10,10,10,10,10,10,10,10,
nuclear@0	1769 10,10,10,10,10,10,10,10,
nuclear@0	1770 10,10,10,10,10,10,10,10,
nuclear@0	1771 10,10,10,10,10,10,10,10,
nuclear@0	1772 10,10,10,10,10,10,10,50,-1};
nuclear@0	1773 const int *headret[]={head1_5,head2_5,head3_5,NULL};
nuclear@0	1774
nuclear@0	1775 fprintf(stderr,"testing max packet segments... ");
nuclear@0	1776 test_pack(packets,headret,0,0,0);
nuclear@0	1777 }
nuclear@0	1778
nuclear@0	1779 {
nuclear@0	1780 /* packet that overspans over an entire page */
nuclear@0	1781 const int packets[]={0,100,130049,259,255,-1};
nuclear@0	1782 const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
nuclear@0	1783
nuclear@0	1784 fprintf(stderr,"testing very large packets... ");
nuclear@0	1785 test_pack(packets,headret,0,0,0);
nuclear@0	1786 }
nuclear@0	1787
nuclear@0	1788 {
nuclear@0	1789 /* test for the libogg 1.1.1 resync in large continuation bug
nuclear@0	1790 found by Josh Coalson) */
nuclear@0	1791 const int packets[]={0,100,130049,259,255,-1};
nuclear@0	1792 const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
nuclear@0	1793
nuclear@0	1794 fprintf(stderr,"testing continuation resync in very large packets... ");
nuclear@0	1795 test_pack(packets,headret,100,2,3);
nuclear@0	1796 }
nuclear@0	1797
nuclear@0	1798 {
nuclear@0	1799 /* term only page. why not? */
nuclear@0	1800 const int packets[]={0,100,64770,-1};
nuclear@0	1801 const int *headret[]={head1_7,head2_7,head3_7,NULL};
nuclear@0	1802
nuclear@0	1803 fprintf(stderr,"testing zero data page (1 nil packet)... ");
nuclear@0	1804 test_pack(packets,headret,0,0,0);
nuclear@0	1805 }
nuclear@0	1806
nuclear@0	1807
nuclear@0	1808
nuclear@0	1809 {
nuclear@0	1810 /* build a bunch of pages for testing */
nuclear@0	1811 unsigned char data=_ogg_malloc(10241024);
nuclear@0	1812 int pl[]={0, 1,1,98,4079, 1,1,2954,2057, 76,34,912,0,234,1000,1000, 1000,300,-1};
nuclear@0	1813 int inptr=0,i,j;
nuclear@0	1814 ogg_page og[5];
nuclear@0	1815
nuclear@0	1816 ogg_stream_reset(&os_en);
nuclear@0	1817
nuclear@0	1818 for(i=0;pl[i]!=-1;i++){
nuclear@0	1819 ogg_packet op;
nuclear@0	1820 int len=pl[i];
nuclear@0	1821
nuclear@0	1822 op.packet=data+inptr;
nuclear@0	1823 op.bytes=len;
nuclear@0	1824 op.e_o_s=(pl[i+1]<0?1:0);
nuclear@0	1825 op.granulepos=(i+1)*1000;
nuclear@0	1826
nuclear@0	1827 for(j=0;j<len;j++)data[inptr++]=i+j;
nuclear@0	1828 ogg_stream_packetin(&os_en,&op);
nuclear@0	1829 }
nuclear@0	1830
nuclear@0	1831 _ogg_free(data);
nuclear@0	1832
nuclear@0	1833 /* retrieve finished pages */
nuclear@0	1834 for(i=0;i<5;i++){
nuclear@0	1835 if(ogg_stream_pageout(&os_en,&og[i])==0){
nuclear@0	1836 fprintf(stderr,"Too few pages output building sync tests!\n");
nuclear@0	1837 exit(1);
nuclear@0	1838 }
nuclear@0	1839 copy_page(&og[i]);
nuclear@0	1840 }
nuclear@0	1841
nuclear@0	1842 /* Test lost pages on pagein/packetout: no rollback */
nuclear@0	1843 {
nuclear@0	1844 ogg_page temp;
nuclear@0	1845 ogg_packet test;
nuclear@0	1846
nuclear@0	1847 fprintf(stderr,"Testing loss of pages... ");
nuclear@0	1848
nuclear@0	1849 ogg_sync_reset(&oy);
nuclear@0	1850 ogg_stream_reset(&os_de);
nuclear@0	1851 for(i=0;i<5;i++){
nuclear@0	1852 memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
nuclear@0	1853 og[i].header_len);
nuclear@0	1854 ogg_sync_wrote(&oy,og[i].header_len);
nuclear@0	1855 memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
nuclear@0	1856 ogg_sync_wrote(&oy,og[i].body_len);
nuclear@0	1857 }
nuclear@0	1858
nuclear@0	1859 ogg_sync_pageout(&oy,&temp);
nuclear@0	1860 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1861 ogg_sync_pageout(&oy,&temp);
nuclear@0	1862 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1863 ogg_sync_pageout(&oy,&temp);
nuclear@0	1864 /* skip */
nuclear@0	1865 ogg_sync_pageout(&oy,&temp);
nuclear@0	1866 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1867
nuclear@0	1868 /* do we get the expected results/packets? */
nuclear@0	1869
nuclear@0	1870 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1871 checkpacket(&test,0,0,0);
nuclear@0	1872 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1873 checkpacket(&test,1,1,-1);
nuclear@0	1874 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1875 checkpacket(&test,1,2,-1);
nuclear@0	1876 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1877 checkpacket(&test,98,3,-1);
nuclear@0	1878 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1879 checkpacket(&test,4079,4,5000);
nuclear@0	1880 if(ogg_stream_packetout(&os_de,&test)!=-1){
nuclear@0	1881 fprintf(stderr,"Error: loss of page did not return error\n");
nuclear@0	1882 exit(1);
nuclear@0	1883 }
nuclear@0	1884 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1885 checkpacket(&test,76,9,-1);
nuclear@0	1886 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1887 checkpacket(&test,34,10,-1);
nuclear@0	1888 fprintf(stderr,"ok.\n");
nuclear@0	1889 }
nuclear@0	1890
nuclear@0	1891 /* Test lost pages on pagein/packetout: rollback with continuation */
nuclear@0	1892 {
nuclear@0	1893 ogg_page temp;
nuclear@0	1894 ogg_packet test;
nuclear@0	1895
nuclear@0	1896 fprintf(stderr,"Testing loss of pages (rollback required)... ");
nuclear@0	1897
nuclear@0	1898 ogg_sync_reset(&oy);
nuclear@0	1899 ogg_stream_reset(&os_de);
nuclear@0	1900 for(i=0;i<5;i++){
nuclear@0	1901 memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
nuclear@0	1902 og[i].header_len);
nuclear@0	1903 ogg_sync_wrote(&oy,og[i].header_len);
nuclear@0	1904 memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
nuclear@0	1905 ogg_sync_wrote(&oy,og[i].body_len);
nuclear@0	1906 }
nuclear@0	1907
nuclear@0	1908 ogg_sync_pageout(&oy,&temp);
nuclear@0	1909 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1910 ogg_sync_pageout(&oy,&temp);
nuclear@0	1911 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1912 ogg_sync_pageout(&oy,&temp);
nuclear@0	1913 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1914 ogg_sync_pageout(&oy,&temp);
nuclear@0	1915 /* skip */
nuclear@0	1916 ogg_sync_pageout(&oy,&temp);
nuclear@0	1917 ogg_stream_pagein(&os_de,&temp);
nuclear@0	1918
nuclear@0	1919 /* do we get the expected results/packets? */
nuclear@0	1920
nuclear@0	1921 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1922 checkpacket(&test,0,0,0);
nuclear@0	1923 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1924 checkpacket(&test,1,1,-1);
nuclear@0	1925 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1926 checkpacket(&test,1,2,-1);
nuclear@0	1927 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1928 checkpacket(&test,98,3,-1);
nuclear@0	1929 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1930 checkpacket(&test,4079,4,5000);
nuclear@0	1931 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1932 checkpacket(&test,1,5,-1);
nuclear@0	1933 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1934 checkpacket(&test,1,6,-1);
nuclear@0	1935 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1936 checkpacket(&test,2954,7,-1);
nuclear@0	1937 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1938 checkpacket(&test,2057,8,9000);
nuclear@0	1939 if(ogg_stream_packetout(&os_de,&test)!=-1){
nuclear@0	1940 fprintf(stderr,"Error: loss of page did not return error\n");
nuclear@0	1941 exit(1);
nuclear@0	1942 }
nuclear@0	1943 if(ogg_stream_packetout(&os_de,&test)!=1)error();
nuclear@0	1944 checkpacket(&test,300,17,18000);
nuclear@0	1945 fprintf(stderr,"ok.\n");
nuclear@0	1946 }
nuclear@0	1947
nuclear@0	1948 /* the rest only test sync */
nuclear@0	1949 {
nuclear@0	1950 ogg_page og_de;
nuclear@0	1951 /* Test fractional page inputs: incomplete capture */
nuclear@0	1952 fprintf(stderr,"Testing sync on partial inputs... ");
nuclear@0	1953 ogg_sync_reset(&oy);
nuclear@0	1954 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
nuclear@0	1955 3);
nuclear@0	1956 ogg_sync_wrote(&oy,3);
nuclear@0	1957 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	1958
nuclear@0	1959 /* Test fractional page inputs: incomplete fixed header */
nuclear@0	1960 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
nuclear@0	1961 20);
nuclear@0	1962 ogg_sync_wrote(&oy,20);
nuclear@0	1963 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	1964
nuclear@0	1965 /* Test fractional page inputs: incomplete header */
nuclear@0	1966 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
nuclear@0	1967 5);
nuclear@0	1968 ogg_sync_wrote(&oy,5);
nuclear@0	1969 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	1970
nuclear@0	1971 /* Test fractional page inputs: incomplete body */
nuclear@0	1972
nuclear@0	1973 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
nuclear@0	1974 og[1].header_len-28);
nuclear@0	1975 ogg_sync_wrote(&oy,og[1].header_len-28);
nuclear@0	1976 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	1977
nuclear@0	1978 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
nuclear@0	1979 ogg_sync_wrote(&oy,1000);
nuclear@0	1980 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	1981
nuclear@0	1982 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
nuclear@0	1983 og[1].body_len-1000);
nuclear@0	1984 ogg_sync_wrote(&oy,og[1].body_len-1000);
nuclear@0	1985 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	1986
nuclear@0	1987 fprintf(stderr,"ok.\n");
nuclear@0	1988 }
nuclear@0	1989
nuclear@0	1990 /* Test fractional page inputs: page + incomplete capture */
nuclear@0	1991 {
nuclear@0	1992 ogg_page og_de;
nuclear@0	1993 fprintf(stderr,"Testing sync on 1+partial inputs... ");
nuclear@0	1994 ogg_sync_reset(&oy);
nuclear@0	1995
nuclear@0	1996 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
nuclear@0	1997 og[1].header_len);
nuclear@0	1998 ogg_sync_wrote(&oy,og[1].header_len);
nuclear@0	1999
nuclear@0	2000 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
nuclear@0	2001 og[1].body_len);
nuclear@0	2002 ogg_sync_wrote(&oy,og[1].body_len);
nuclear@0	2003
nuclear@0	2004 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
nuclear@0	2005 20);
nuclear@0	2006 ogg_sync_wrote(&oy,20);
nuclear@0	2007 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2008 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	2009
nuclear@0	2010 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
nuclear@0	2011 og[1].header_len-20);
nuclear@0	2012 ogg_sync_wrote(&oy,og[1].header_len-20);
nuclear@0	2013 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
nuclear@0	2014 og[1].body_len);
nuclear@0	2015 ogg_sync_wrote(&oy,og[1].body_len);
nuclear@0	2016 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2017
nuclear@0	2018 fprintf(stderr,"ok.\n");
nuclear@0	2019 }
nuclear@0	2020
nuclear@0	2021 /* Test recapture: garbage + page */
nuclear@0	2022 {
nuclear@0	2023 ogg_page og_de;
nuclear@0	2024 fprintf(stderr,"Testing search for capture... ");
nuclear@0	2025 ogg_sync_reset(&oy);
nuclear@0	2026
nuclear@0	2027 /* 'garbage' */
nuclear@0	2028 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
nuclear@0	2029 og[1].body_len);
nuclear@0	2030 ogg_sync_wrote(&oy,og[1].body_len);
nuclear@0	2031
nuclear@0	2032 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
nuclear@0	2033 og[1].header_len);
nuclear@0	2034 ogg_sync_wrote(&oy,og[1].header_len);
nuclear@0	2035
nuclear@0	2036 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
nuclear@0	2037 og[1].body_len);
nuclear@0	2038 ogg_sync_wrote(&oy,og[1].body_len);
nuclear@0	2039
nuclear@0	2040 memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
nuclear@0	2041 20);
nuclear@0	2042 ogg_sync_wrote(&oy,20);
nuclear@0	2043 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	2044 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2045 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	2046
nuclear@0	2047 memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
nuclear@0	2048 og[2].header_len-20);
nuclear@0	2049 ogg_sync_wrote(&oy,og[2].header_len-20);
nuclear@0	2050 memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
nuclear@0	2051 og[2].body_len);
nuclear@0	2052 ogg_sync_wrote(&oy,og[2].body_len);
nuclear@0	2053 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2054
nuclear@0	2055 fprintf(stderr,"ok.\n");
nuclear@0	2056 }
nuclear@0	2057
nuclear@0	2058 /* Test recapture: page + garbage + page */
nuclear@0	2059 {
nuclear@0	2060 ogg_page og_de;
nuclear@0	2061 fprintf(stderr,"Testing recapture... ");
nuclear@0	2062 ogg_sync_reset(&oy);
nuclear@0	2063
nuclear@0	2064 memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
nuclear@0	2065 og[1].header_len);
nuclear@0	2066 ogg_sync_wrote(&oy,og[1].header_len);
nuclear@0	2067
nuclear@0	2068 memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
nuclear@0	2069 og[1].body_len);
nuclear@0	2070 ogg_sync_wrote(&oy,og[1].body_len);
nuclear@0	2071
nuclear@0	2072 memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
nuclear@0	2073 og[2].header_len);
nuclear@0	2074 ogg_sync_wrote(&oy,og[2].header_len);
nuclear@0	2075
nuclear@0	2076 memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
nuclear@0	2077 og[2].header_len);
nuclear@0	2078 ogg_sync_wrote(&oy,og[2].header_len);
nuclear@0	2079
nuclear@0	2080 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2081
nuclear@0	2082 memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
nuclear@0	2083 og[2].body_len-5);
nuclear@0	2084 ogg_sync_wrote(&oy,og[2].body_len-5);
nuclear@0	2085
nuclear@0	2086 memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
nuclear@0	2087 og[3].header_len);
nuclear@0	2088 ogg_sync_wrote(&oy,og[3].header_len);
nuclear@0	2089
nuclear@0	2090 memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
nuclear@0	2091 og[3].body_len);
nuclear@0	2092 ogg_sync_wrote(&oy,og[3].body_len);
nuclear@0	2093
nuclear@0	2094 if(ogg_sync_pageout(&oy,&og_de)>0)error();
nuclear@0	2095 if(ogg_sync_pageout(&oy,&og_de)<=0)error();
nuclear@0	2096
nuclear@0	2097 fprintf(stderr,"ok.\n");
nuclear@0	2098 }
nuclear@0	2099
nuclear@0	2100 /* Free page data that was previously copied */
nuclear@0	2101 {
nuclear@0	2102 for(i=0;i<5;i++){
nuclear@0	2103 free_page(&og[i]);
nuclear@0	2104 }
nuclear@0	2105 }
nuclear@0	2106 }
nuclear@0	2107
nuclear@0	2108 return(0);
nuclear@0	2109 }
nuclear@0	2110
nuclear@0	2111 #endif