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