diff options
Diffstat (limited to 'songdbj/com/jcraft/jogg/StreamState.java')
-rw-r--r-- | songdbj/com/jcraft/jogg/StreamState.java | 657 |
1 files changed, 0 insertions, 657 deletions
diff --git a/songdbj/com/jcraft/jogg/StreamState.java b/songdbj/com/jcraft/jogg/StreamState.java deleted file mode 100644 index 2f34b374f8..0000000000 --- a/songdbj/com/jcraft/jogg/StreamState.java +++ /dev/null | |||
@@ -1,657 +0,0 @@ | |||
1 | /* JOrbis | ||
2 | * Copyright (C) 2000 ymnk, JCraft,Inc. | ||
3 | * | ||
4 | * Written by: 2000 ymnk<ymnk@jcraft.com> | ||
5 | * | ||
6 | * Many thanks to | ||
7 | * Monty <monty@xiph.org> and | ||
8 | * The XIPHOPHORUS Company http://www.xiph.org/ . | ||
9 | * JOrbis has been based on their awesome works, Vorbis codec. | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU Library General Public License | ||
13 | * as published by the Free Software Foundation; either version 2 of | ||
14 | * the License, or (at your option) any later version. | ||
15 | |||
16 | * This program is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU Library General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU Library General Public | ||
22 | * License along with this program; if not, write to the Free Software | ||
23 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
24 | */ | ||
25 | |||
26 | package com.jcraft.jogg; | ||
27 | |||
28 | public class StreamState{ | ||
29 | byte[] body_data; /* bytes from packet bodies */ | ||
30 | int body_storage; /* storage elements allocated */ | ||
31 | int body_fill; /* elements stored; fill mark */ | ||
32 | private int body_returned; /* elements of fill returned */ | ||
33 | |||
34 | |||
35 | int[] lacing_vals; /* The values that will go to the segment table */ | ||
36 | long[] granule_vals; /* pcm_pos values for headers. Not compact | ||
37 | this way, but it is simple coupled to the | ||
38 | lacing fifo */ | ||
39 | int lacing_storage; | ||
40 | int lacing_fill; | ||
41 | int lacing_packet; | ||
42 | int lacing_returned; | ||
43 | |||
44 | byte[] header=new byte[282]; /* working space for header encode */ | ||
45 | int header_fill; | ||
46 | |||
47 | public int e_o_s; /* set when we have buffered the last packet in the | ||
48 | logical bitstream */ | ||
49 | int b_o_s; /* set after we've written the initial page | ||
50 | of a logical bitstream */ | ||
51 | int serialno; | ||
52 | int pageno; | ||
53 | long packetno; /* sequence number for decode; the framing | ||
54 | knows where there's a hole in the data, | ||
55 | but we need coupling so that the codec | ||
56 | (which is in a seperate abstraction | ||
57 | layer) also knows about the gap */ | ||
58 | long granulepos; | ||
59 | |||
60 | public StreamState(){ | ||
61 | init(); | ||
62 | } | ||
63 | |||
64 | StreamState(int serialno){ | ||
65 | this(); | ||
66 | init(serialno); | ||
67 | } | ||
68 | void init(){ | ||
69 | body_storage=16*1024; | ||
70 | body_data=new byte[body_storage]; | ||
71 | lacing_storage=1024; | ||
72 | lacing_vals=new int[lacing_storage]; | ||
73 | granule_vals=new long[lacing_storage]; | ||
74 | } | ||
75 | public void init(int serialno){ | ||
76 | if(body_data==null){ init(); } | ||
77 | else{ | ||
78 | for(int i=0; i<body_data.length; i++) body_data[i]=0; | ||
79 | for(int i=0; i<lacing_vals.length; i++) lacing_vals[i]=0; | ||
80 | for(int i=0; i<granule_vals.length; i++) granule_vals[i]=0; | ||
81 | } | ||
82 | this.serialno=serialno; | ||
83 | } | ||
84 | public void clear(){ | ||
85 | body_data=null; | ||
86 | lacing_vals=null; | ||
87 | granule_vals=null; | ||
88 | //memset(os,0,sizeof(ogg_stream_state)); | ||
89 | } | ||
90 | void destroy(){ | ||
91 | clear(); | ||
92 | } | ||
93 | void body_expand(int needed){ | ||
94 | if(body_storage<=body_fill+needed){ | ||
95 | body_storage+=(needed+1024); | ||
96 | byte[] foo=new byte[body_storage]; | ||
97 | System.arraycopy(body_data, 0, foo, 0, body_data.length); | ||
98 | body_data=foo; | ||
99 | //System.out.println("expand: body_fill="+body_fill+", body_storage="+body_data.length); | ||
100 | } | ||
101 | } | ||
102 | void lacing_expand(int needed){ | ||
103 | if(lacing_storage<=lacing_fill+needed){ | ||
104 | lacing_storage+=(needed+32); | ||
105 | int[] foo=new int[lacing_storage]; | ||
106 | System.arraycopy(lacing_vals, 0, foo, 0, lacing_vals.length); | ||
107 | lacing_vals=foo; | ||
108 | |||
109 | long[] bar=new long[lacing_storage]; | ||
110 | System.arraycopy(granule_vals, 0, bar, 0, granule_vals.length); | ||
111 | granule_vals=bar; | ||
112 | } | ||
113 | } | ||
114 | |||
115 | /* submit data to the internal buffer of the framing engine */ | ||
116 | public int packetin(Packet op){ | ||
117 | int lacing_val=op.bytes/255+1; | ||
118 | |||
119 | if(body_returned!=0){ | ||
120 | /* advance packet data according to the body_returned pointer. We | ||
121 | had to keep it around to return a pointer into the buffer last | ||
122 | call */ | ||
123 | |||
124 | body_fill-=body_returned; | ||
125 | if(body_fill!=0){ | ||
126 | // memmove(os->body_data,os->body_data+os->body_returned, | ||
127 | // os->body_fill*sizeof(char)); | ||
128 | System.arraycopy(body_data, body_returned, body_data, 0, body_fill); | ||
129 | } | ||
130 | body_returned=0; | ||
131 | } | ||
132 | |||
133 | /* make sure we have the buffer storage */ | ||
134 | body_expand(op.bytes); | ||
135 | lacing_expand(lacing_val); | ||
136 | |||
137 | /* Copy in the submitted packet. Yes, the copy is a waste; this is | ||
138 | the liability of overly clean abstraction for the time being. It | ||
139 | will actually be fairly easy to eliminate the extra copy in the | ||
140 | future */ | ||
141 | |||
142 | System.arraycopy(op.packet_base, op.packet, body_data, body_fill, op.bytes); | ||
143 | body_fill+=op.bytes; | ||
144 | //System.out.println("add: "+body_fill); | ||
145 | |||
146 | /* Store lacing vals for this packet */ | ||
147 | int j; | ||
148 | for(j=0;j<lacing_val-1;j++){ | ||
149 | lacing_vals[lacing_fill+j]=255; | ||
150 | granule_vals[lacing_fill+j]=granulepos; | ||
151 | } | ||
152 | lacing_vals[lacing_fill+j]=(op.bytes)%255; | ||
153 | granulepos=granule_vals[lacing_fill+j]=op.granulepos; | ||
154 | |||
155 | /* flag the first segment as the beginning of the packet */ | ||
156 | lacing_vals[lacing_fill]|= 0x100; | ||
157 | |||
158 | lacing_fill+=lacing_val; | ||
159 | |||
160 | /* for the sake of completeness */ | ||
161 | packetno++; | ||
162 | |||
163 | if(op.e_o_s!=0)e_o_s=1; | ||
164 | return(0); | ||
165 | } | ||
166 | |||
167 | public int packetout(Packet op){ | ||
168 | |||
169 | /* The last part of decode. We have the stream broken into packet | ||
170 | segments. Now we need to group them into packets (or return the | ||
171 | out of sync markers) */ | ||
172 | |||
173 | int ptr=lacing_returned; | ||
174 | |||
175 | if(lacing_packet<=ptr){ | ||
176 | return(0); | ||
177 | } | ||
178 | |||
179 | if((lacing_vals[ptr]&0x400)!=0){ | ||
180 | /* We lost sync here; let the app know */ | ||
181 | lacing_returned++; | ||
182 | |||
183 | /* we need to tell the codec there's a gap; it might need to | ||
184 | handle previous packet dependencies. */ | ||
185 | packetno++; | ||
186 | return(-1); | ||
187 | } | ||
188 | |||
189 | /* Gather the whole packet. We'll have no holes or a partial packet */ | ||
190 | { | ||
191 | int size=lacing_vals[ptr]&0xff; | ||
192 | int bytes=0; | ||
193 | |||
194 | op.packet_base=body_data; | ||
195 | op.packet=body_returned; | ||
196 | op.e_o_s=lacing_vals[ptr]&0x200; /* last packet of the stream? */ | ||
197 | op.b_o_s=lacing_vals[ptr]&0x100; /* first packet of the stream? */ | ||
198 | bytes+=size; | ||
199 | |||
200 | while(size==255){ | ||
201 | int val=lacing_vals[++ptr]; | ||
202 | size=val&0xff; | ||
203 | if((val&0x200)!=0)op.e_o_s=0x200; | ||
204 | bytes+=size; | ||
205 | } | ||
206 | |||
207 | op.packetno=packetno; | ||
208 | op.granulepos=granule_vals[ptr]; | ||
209 | op.bytes=bytes; | ||
210 | |||
211 | //System.out.println(this+" # body_returned="+body_returned); | ||
212 | body_returned+=bytes; | ||
213 | //System.out.println(this+"## body_returned="+body_returned); | ||
214 | |||
215 | lacing_returned=ptr+1; | ||
216 | } | ||
217 | packetno++; | ||
218 | return(1); | ||
219 | } | ||
220 | |||
221 | |||
222 | // add the incoming page to the stream state; we decompose the page | ||
223 | // into packet segments here as well. | ||
224 | |||
225 | public int pagein(Page og){ | ||
226 | byte[] header_base=og.header_base; | ||
227 | int header=og.header; | ||
228 | byte[] body_base=og.body_base; | ||
229 | int body=og.body; | ||
230 | int bodysize=og.body_len; | ||
231 | int segptr=0; | ||
232 | |||
233 | int version=og.version(); | ||
234 | int continued=og.continued(); | ||
235 | int bos=og.bos(); | ||
236 | int eos=og.eos(); | ||
237 | long granulepos=og.granulepos(); | ||
238 | int _serialno=og.serialno(); | ||
239 | int _pageno=og.pageno(); | ||
240 | int segments=header_base[header+26]&0xff; | ||
241 | |||
242 | // clean up 'returned data' | ||
243 | { | ||
244 | int lr=lacing_returned; | ||
245 | int br=body_returned; | ||
246 | |||
247 | // body data | ||
248 | |||
249 | //System.out.println("br="+br+", body_fill="+body_fill); | ||
250 | |||
251 | if(br!=0){ | ||
252 | body_fill-=br; | ||
253 | if(body_fill!=0){ | ||
254 | System.arraycopy(body_data, br, body_data, 0, body_fill); | ||
255 | } | ||
256 | body_returned=0; | ||
257 | } | ||
258 | |||
259 | //System.out.println("?? br="+br+", body_fill="+body_fill+" body_returned="+body_returned); | ||
260 | |||
261 | if(lr!=0){ | ||
262 | // segment table | ||
263 | if((lacing_fill-lr)!=0){ | ||
264 | System.arraycopy(lacing_vals, lr, lacing_vals, 0, lacing_fill-lr); | ||
265 | System.arraycopy(granule_vals, lr, granule_vals, 0, lacing_fill-lr); | ||
266 | } | ||
267 | lacing_fill-=lr; | ||
268 | lacing_packet-=lr; | ||
269 | lacing_returned=0; | ||
270 | } | ||
271 | } | ||
272 | |||
273 | // check the serial number | ||
274 | if(_serialno!=serialno)return(-1); | ||
275 | if(version>0)return(-1); | ||
276 | |||
277 | lacing_expand(segments+1); | ||
278 | |||
279 | // are we in sequence? | ||
280 | if(_pageno!=pageno){ | ||
281 | int i; | ||
282 | |||
283 | // unroll previous partial packet (if any) | ||
284 | for(i=lacing_packet;i<lacing_fill;i++){ | ||
285 | body_fill-=lacing_vals[i]&0xff; | ||
286 | //System.out.println("??"); | ||
287 | } | ||
288 | lacing_fill=lacing_packet; | ||
289 | |||
290 | // make a note of dropped data in segment table | ||
291 | if(pageno!=-1){ | ||
292 | lacing_vals[lacing_fill++]=0x400; | ||
293 | lacing_packet++; | ||
294 | } | ||
295 | |||
296 | // are we a 'continued packet' page? If so, we'll need to skip | ||
297 | // some segments | ||
298 | if(continued!=0){ | ||
299 | bos=0; | ||
300 | for(;segptr<segments;segptr++){ | ||
301 | int val=(header_base[header+27+segptr]&0xff); | ||
302 | body+=val; | ||
303 | bodysize-=val; | ||
304 | if(val<255){ | ||
305 | segptr++; | ||
306 | break; | ||
307 | } | ||
308 | } | ||
309 | } | ||
310 | } | ||
311 | |||
312 | //System.out.println("bodysize="+bodysize); | ||
313 | |||
314 | if(bodysize!=0){ | ||
315 | body_expand(bodysize); | ||
316 | System.arraycopy(body_base, body, body_data, body_fill, bodysize); | ||
317 | body_fill+=bodysize; | ||
318 | } | ||
319 | |||
320 | //System.out.println("bodyfill="+body_fill); | ||
321 | |||
322 | { | ||
323 | int saved=-1; | ||
324 | while(segptr<segments){ | ||
325 | int val=(header_base[header+27+segptr]&0xff); | ||
326 | lacing_vals[lacing_fill]=val; | ||
327 | granule_vals[lacing_fill]=-1; | ||
328 | |||
329 | if(bos!=0){ | ||
330 | lacing_vals[lacing_fill]|=0x100; | ||
331 | bos=0; | ||
332 | } | ||
333 | |||
334 | if(val<255)saved=lacing_fill; | ||
335 | |||
336 | lacing_fill++; | ||
337 | segptr++; | ||
338 | |||
339 | if(val<255)lacing_packet=lacing_fill; | ||
340 | } | ||
341 | |||
342 | /* set the granulepos on the last pcmval of the last full packet */ | ||
343 | if(saved!=-1){ | ||
344 | granule_vals[saved]=granulepos; | ||
345 | } | ||
346 | } | ||
347 | |||
348 | if(eos!=0){ | ||
349 | e_o_s=1; | ||
350 | if(lacing_fill>0) | ||
351 | lacing_vals[lacing_fill-1]|=0x200; | ||
352 | } | ||
353 | |||
354 | pageno=_pageno+1; | ||
355 | return(0); | ||
356 | } | ||
357 | |||
358 | |||
359 | /* This will flush remaining packets into a page (returning nonzero), | ||
360 | even if there is not enough data to trigger a flush normally | ||
361 | (undersized page). If there are no packets or partial packets to | ||
362 | flush, ogg_stream_flush returns 0. Note that ogg_stream_flush will | ||
363 | try to flush a normal sized page like ogg_stream_pageout; a call to | ||
364 | ogg_stream_flush does not gurantee that all packets have flushed. | ||
365 | Only a return value of 0 from ogg_stream_flush indicates all packet | ||
366 | data is flushed into pages. | ||
367 | |||
368 | ogg_stream_page will flush the last page in a stream even if it's | ||
369 | undersized; you almost certainly want to use ogg_stream_pageout | ||
370 | (and *not* ogg_stream_flush) unless you need to flush an undersized | ||
371 | page in the middle of a stream for some reason. */ | ||
372 | |||
373 | public int flush(Page og){ | ||
374 | |||
375 | //System.out.println(this+" ---body_returned: "+body_returned); | ||
376 | |||
377 | int i; | ||
378 | int vals=0; | ||
379 | int maxvals=(lacing_fill>255?255:lacing_fill); | ||
380 | int bytes=0; | ||
381 | int acc=0; | ||
382 | long granule_pos=granule_vals[0]; | ||
383 | |||
384 | if(maxvals==0)return(0); | ||
385 | |||
386 | /* construct a page */ | ||
387 | /* decide how many segments to include */ | ||
388 | |||
389 | /* If this is the initial header case, the first page must only include | ||
390 | the initial header packet */ | ||
391 | if(b_o_s==0){ /* 'initial header page' case */ | ||
392 | granule_pos=0; | ||
393 | for(vals=0;vals<maxvals;vals++){ | ||
394 | if((lacing_vals[vals]&0x0ff)<255){ | ||
395 | vals++; | ||
396 | break; | ||
397 | } | ||
398 | } | ||
399 | } | ||
400 | else{ | ||
401 | for(vals=0;vals<maxvals;vals++){ | ||
402 | if(acc>4096)break; | ||
403 | acc+=(lacing_vals[vals]&0x0ff); | ||
404 | granule_pos=granule_vals[vals]; | ||
405 | } | ||
406 | } | ||
407 | |||
408 | /* construct the header in temp storage */ | ||
409 | System.arraycopy("OggS".getBytes(), 0, header, 0, 4); | ||
410 | |||
411 | /* stream structure version */ | ||
412 | header[4]=0x00; | ||
413 | |||
414 | /* continued packet flag? */ | ||
415 | header[5]=0x00; | ||
416 | if((lacing_vals[0]&0x100)==0)header[5]|=0x01; | ||
417 | /* first page flag? */ | ||
418 | if(b_o_s==0) header[5]|=0x02; | ||
419 | /* last page flag? */ | ||
420 | if(e_o_s!=0 && lacing_fill==vals) header[5]|=0x04; | ||
421 | b_o_s=1; | ||
422 | |||
423 | /* 64 bits of PCM position */ | ||
424 | for(i=6;i<14;i++){ | ||
425 | header[i]=(byte)granule_pos; | ||
426 | granule_pos>>>=8; | ||
427 | } | ||
428 | |||
429 | /* 32 bits of stream serial number */ | ||
430 | { | ||
431 | int _serialno=serialno; | ||
432 | for(i=14;i<18;i++){ | ||
433 | header[i]=(byte)_serialno; | ||
434 | _serialno>>>=8; | ||
435 | } | ||
436 | } | ||
437 | |||
438 | /* 32 bits of page counter (we have both counter and page header | ||
439 | because this val can roll over) */ | ||
440 | if(pageno==-1)pageno=0; /* because someone called | ||
441 | stream_reset; this would be a | ||
442 | strange thing to do in an | ||
443 | encode stream, but it has | ||
444 | plausible uses */ | ||
445 | { | ||
446 | int _pageno=pageno++; | ||
447 | for(i=18;i<22;i++){ | ||
448 | header[i]=(byte)_pageno; | ||
449 | _pageno>>>=8; | ||
450 | } | ||
451 | } | ||
452 | |||
453 | /* zero for computation; filled in later */ | ||
454 | header[22]=0; | ||
455 | header[23]=0; | ||
456 | header[24]=0; | ||
457 | header[25]=0; | ||
458 | |||
459 | /* segment table */ | ||
460 | header[26]=(byte)vals; | ||
461 | for(i=0;i<vals;i++){ | ||
462 | header[i+27]=(byte)lacing_vals[i]; | ||
463 | bytes+=(header[i+27]&0xff); | ||
464 | } | ||
465 | |||
466 | /* set pointers in the ogg_page struct */ | ||
467 | og.header_base=header; | ||
468 | og.header=0; | ||
469 | og.header_len=header_fill=vals+27; | ||
470 | og.body_base=body_data; | ||
471 | og.body=body_returned; | ||
472 | og.body_len=bytes; | ||
473 | |||
474 | /* advance the lacing data and set the body_returned pointer */ | ||
475 | |||
476 | //System.out.println("###body_returned: "+body_returned); | ||
477 | |||
478 | lacing_fill-=vals; | ||
479 | System.arraycopy(lacing_vals, vals, lacing_vals, 0, lacing_fill*4); | ||
480 | System.arraycopy(granule_vals, vals, granule_vals, 0, lacing_fill*8); | ||
481 | body_returned+=bytes; | ||
482 | |||
483 | //System.out.println("####body_returned: "+body_returned); | ||
484 | |||
485 | /* calculate the checksum */ | ||
486 | |||
487 | og.checksum(); | ||
488 | |||
489 | /* done */ | ||
490 | return(1); | ||
491 | } | ||
492 | |||
493 | |||
494 | /* This constructs pages from buffered packet segments. The pointers | ||
495 | returned are to static buffers; do not free. The returned buffers are | ||
496 | good only until the next call (using the same ogg_stream_state) */ | ||
497 | public int pageout(Page og){ | ||
498 | // if(body_returned!=0){ | ||
499 | // /* advance packet data according to the body_returned pointer. We | ||
500 | // had to keep it around to return a pointer into the buffer last | ||
501 | // call */ | ||
502 | // | ||
503 | // body_fill-=body_returned; | ||
504 | // if(body_fill!=0){ // overlap? | ||
505 | // System.arraycopy(body_data, body_returned, body_data, 0, body_fill); | ||
506 | // } | ||
507 | // body_returned=0; | ||
508 | // } | ||
509 | // | ||
510 | //System.out.println("pageout: e_o_s="+e_o_s+" lacing_fill="+lacing_fill+" body_fill="+body_fill+", lacing_fill="+lacing_fill+" b_o_s="+b_o_s); | ||
511 | // | ||
512 | // if((e_o_s!=0&&lacing_fill!=0) || /* 'were done, now flush' case */ | ||
513 | // body_fill > 4096 || /* 'page nominal size' case */ | ||
514 | // lacing_fill>=255 || /* 'segment table full' case */ | ||
515 | // (lacing_fill!=0&&b_o_s==0)){ /* 'initial header page' case */ | ||
516 | // int vals=0,bytes=0; | ||
517 | // int maxvals=(lacing_fill>255?255:lacing_fill); | ||
518 | // long acc=0; | ||
519 | // long pcm_pos=granule_vals[0]; | ||
520 | // | ||
521 | // /* construct a page */ | ||
522 | // /* decide how many segments to include */ | ||
523 | // | ||
524 | // /* If this is the initial header case, the first page must only include | ||
525 | // the initial header packet */ | ||
526 | // if(b_o_s==0){ /* 'initial header page' case */ | ||
527 | // pcm_pos=0; | ||
528 | // for(vals=0;vals<maxvals;vals++){ | ||
529 | // if((lacing_vals[vals]&0x0ff)<255){ | ||
530 | // vals++; | ||
531 | // break; | ||
532 | // } | ||
533 | // } | ||
534 | // } | ||
535 | // else{ | ||
536 | // for(vals=0;vals<maxvals;vals++){ | ||
537 | // if(acc>4096)break; | ||
538 | // acc+=lacing_vals[vals]&0x0ff; | ||
539 | // pcm_pos=granule_vals[vals]; | ||
540 | // } | ||
541 | // } | ||
542 | // | ||
543 | // /* construct the header in temp storage */ | ||
544 | // System.arraycopy("OggS".getBytes(), 0, header, 0, 4); | ||
545 | // | ||
546 | // /* stream structure version */ | ||
547 | // header[4]=0x00; | ||
548 | // | ||
549 | // /* continued packet flag? */ | ||
550 | // header[5]=0x00; | ||
551 | // if((lacing_vals[0]&0x100)==0)header[5]|=0x01; | ||
552 | // /* first page flag? */ | ||
553 | // if(b_o_s==0)header[5]|=0x02; | ||
554 | // /* last page flag? */ | ||
555 | // if(e_o_s!=0 && lacing_fill==vals)header[5]|=0x04; | ||
556 | // b_o_s=1; | ||
557 | // | ||
558 | // /* 64 bits of PCM position */ | ||
559 | // for(int i=6;i<14;i++){ | ||
560 | // header[i]=(byte)pcm_pos; | ||
561 | // pcm_pos>>>=8; | ||
562 | // } | ||
563 | // | ||
564 | // /* 32 bits of stream serial number */ | ||
565 | // { | ||
566 | // int serialn=serialno; | ||
567 | // for(int i=14;i<18;i++){ | ||
568 | // header[i]=(byte)serialn; | ||
569 | // serialn>>>=8; | ||
570 | // } | ||
571 | // } | ||
572 | // | ||
573 | // | ||
574 | ///* 32 bits of page counter (we have both counter and page header | ||
575 | // because this val can roll over) */ | ||
576 | // if(pageno==-1)pageno=0; /* because someone called | ||
577 | // stream_reset; this would be a | ||
578 | // strange thing to do in an | ||
579 | // encode stream, but it has | ||
580 | // plausible uses */ | ||
581 | // { | ||
582 | // int pagen=pageno++; | ||
583 | // for(int i=18;i<22;i++){ | ||
584 | // header[i]=(byte)pagen; | ||
585 | // pagen>>>=8; | ||
586 | // } | ||
587 | // } | ||
588 | // | ||
589 | // /* zero for computation; filled in later */ | ||
590 | // header[22]=0; | ||
591 | // header[23]=0; | ||
592 | // header[24]=0; | ||
593 | // header[25]=0; | ||
594 | // | ||
595 | // /* segment table */ | ||
596 | // header[26]=(byte)vals; | ||
597 | // for(int i=0;i<vals;i++){ | ||
598 | // header[i+27]=(byte)lacing_vals[i]; | ||
599 | // bytes+=header[i+27]&0xff; | ||
600 | //// bytes+=header[i+27]=(lacing_vals[i]&0xff); | ||
601 | // } | ||
602 | // | ||
603 | // /* advance the lacing data and set the body_returned pointer */ | ||
604 | // | ||
605 | // lacing_fill-=vals; | ||
606 | // System.arraycopy(lacing_vals, vals, lacing_vals, 0, lacing_fill); | ||
607 | // System.arraycopy(granule_vals, vals, granule_vals, 0, lacing_fill); | ||
608 | // body_returned=bytes; | ||
609 | // | ||
610 | // /* set pointers in the ogg_page struct */ | ||
611 | // og.header_base=header; | ||
612 | // og.header=0; | ||
613 | // og.header_len=header_fill=vals+27; | ||
614 | // | ||
615 | // og.body_base=body_data; | ||
616 | // og.body=0; | ||
617 | // og.body_len=bytes; | ||
618 | // | ||
619 | // /* calculate the checksum */ | ||
620 | // | ||
621 | // og.checksum(); | ||
622 | // return(1); | ||
623 | // } | ||
624 | // /* not enough data to construct a page and not end of stream */ | ||
625 | // return(0); | ||
626 | //System.out.println("pageout: "+body_returned); | ||
627 | if((e_o_s!=0&&lacing_fill!=0) || /* 'were done, now flush' case */ | ||
628 | body_fill-body_returned> 4096 || /* 'page nominal size' case */ | ||
629 | lacing_fill>=255 || /* 'segment table full' case */ | ||
630 | (lacing_fill!=0&&b_o_s==0)){ /* 'initial header page' case */ | ||
631 | return flush(og); | ||
632 | } | ||
633 | return 0; | ||
634 | } | ||
635 | |||
636 | public int eof(){ | ||
637 | return e_o_s; | ||
638 | } | ||
639 | |||
640 | public int reset(){ | ||
641 | body_fill=0; | ||
642 | body_returned=0; | ||
643 | |||
644 | lacing_fill=0; | ||
645 | lacing_packet=0; | ||
646 | lacing_returned=0; | ||
647 | |||
648 | header_fill=0; | ||
649 | |||
650 | e_o_s=0; | ||
651 | b_o_s=0; | ||
652 | pageno=-1; | ||
653 | packetno=0; | ||
654 | granulepos=0; | ||
655 | return(0); | ||
656 | } | ||
657 | } | ||