2 #include "serialization.hpp"
15 const uint32_t crc_lookup
[256]= {
16 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
17 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
18 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
19 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
20 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
21 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
22 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
23 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
24 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
25 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
26 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
27 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
28 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
29 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
30 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
31 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
32 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
33 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
34 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
35 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
36 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
37 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
38 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
39 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
40 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
41 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
42 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
43 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
44 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
45 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
46 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
47 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
48 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
49 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
50 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
51 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
52 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
53 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
54 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
55 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
56 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
57 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
58 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
59 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
60 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
61 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
62 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
63 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
64 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
65 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
66 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
67 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
68 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
69 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
70 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
71 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
72 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
73 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
74 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
75 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
76 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
77 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
78 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
79 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4
82 //Grr... Ogg doesn't use the same CRC32 as zlib...
83 uint32_t oggcrc32(uint32_t chain
, const uint8_t* data
, size_t size
)
87 for(size_t i
= 0; i
< size
; i
++)
88 chain
= (chain
<< 8) ^ crc_lookup
[(chain
>> 24) ^ data
[i
]];
94 packet::packet(uint64_t granule
, bool first
, bool last
, bool spans
, bool eos
, bool bos
,
95 const std::vector
<uint8_t>& d
)
106 demuxer::demuxer(std::ostream
& _errors_to
)
107 : errors_to(_errors_to
)
116 damaged_packet
= false;
120 uint64_t demuxer::page_fullseq(uint32_t seq
)
123 return (static_cast<uint64_t>(page_era
+ 1) << 32) + seq
;
125 return (static_cast<uint64_t>(page_era
) << 32) + seq
;
128 void demuxer::update_pageseq(uint32_t new_seq
)
130 if(new_seq
< page_seq
)
135 bool demuxer::complain_lost_page(uint32_t new_seq
, uint32_t stream
)
137 if(new_seq
!= static_cast<uint32_t>(page_seq
+ 1)) {
138 //Some pages are missing!
139 uint64_t first_missing
= page_fullseq(page_seq
) + 1;
140 uint64_t last_missing
= page_fullseq(new_seq
) - 1;
141 if(first_missing
== last_missing
)
142 errors_to
<< "Warning: Ogg demux: Page " << first_missing
<< " missing on stream "
143 << hex::to(stream
) << std::endl
;
145 errors_to
<< "Warning: Ogg demux: Pages " << first_missing
<< "-" << last_missing
146 << " missing on stream " << hex::to(stream
) << std::endl
;
152 void demuxer::complain_continue_errors(unsigned flags
, uint32_t seqno
, uint32_t stream
, uint32_t pkts
,
155 bool continued
= (flags
& 1);
156 bool bos
= (flags
& 2);
157 bool eos
= (flags
& 4);
158 bool incomplete
= (flags
& 8);
159 bool damaged
= (flags
& 16);
160 bool gap
= (flags
& 32);
161 bool data
= (flags
& 64);
163 if(data
&& !damaged
&& !gap
)
164 errors_to
<< "Warning: Ogg demux: Data spilled from previous page but not continued (page "
165 << page_fullseq(seqno
) << " of " << stream
<< ")" << std::endl
;
166 if(data
&& !damaged
&& gap
)
167 errors_to
<< "Warning: Ogg demux: Packet continues to lost page" << std::endl
;
170 errors_to
<< "Warning: Ogg demux: BOS page has CONTINUED set (stream " << stream
<< ")."
172 else if(!data
&& !damaged
&& !gap
)
173 errors_to
<< "Warning: Ogg demux: No Data spilled from previous page but continued (page "
174 << page_fullseq(seqno
) << " of " << stream
<< ")" << std::endl
;
175 if(data
&& !damaged
&& gap
)
176 errors_to
<< "Warning: Ogg demux: Packet continues to/from lost page" << std::endl
;
177 if(!data
&& !damaged
&& gap
)
178 errors_to
<< "Warning: Ogg demux: Packet continues from lost page" << std::endl
;
180 if(incomplete
&& eos
)
181 errors_to
<< "Warning: Ogg demux: EOS page with incomplete packet (stream " << stream
<< ")."
183 if(incomplete
&& pkts
== 1 && granule
!= page::granulepos_none
)
184 errors_to
<< "Warning: Ogg demux: Page should have granulepos NONE (page " << page_fullseq(seqno
)
185 << " of " << stream
<< ")" << std::endl
;
186 if((!incomplete
|| pkts
> 1) && granule
== page::granulepos_none
)
187 errors_to
<< "Warning: Ogg demux: Page should not have granulepos NONE (page " << page_fullseq(seqno
)
188 << " of " << stream
<< ")" << std::endl
;
191 bool demuxer::page_in(const page
& p
)
193 //Is this from the right stream? If not, ignore page.
194 uint32_t stream
= p
.get_stream();
195 if(seen_page
&& stream
!= imprint_stream
)
196 return false; //Wrong stream.
198 throw std::runtime_error("Not ready for page");
199 std::vector
<uint8_t> newbuffer
;
200 uint32_t sequence
= p
.get_sequence();
201 uint32_t pkts
= p
.get_packet_count();
202 uint64_t granulepos
= p
.get_granulepos();
203 bool bos
= p
.get_bos();
204 bool eos
= p
.get_eos();
205 bool continued
= p
.get_continue();
206 bool incomplete
= p
.get_last_packet_incomplete();
207 //BOS flag can only be set on first page.
208 if(granulepos
< last_granulepos
&& granulepos
!= page::granulepos_none
)
209 errors_to
<< "Warning: Ogg demux: Non-monotonic granulepos" << std::endl
;
210 if(!seen_page
&& !bos
)
211 errors_to
<< "Warning: Ogg demux: First page does not have BOS set." << std::endl
;
213 errors_to
<< "Warning: Ogg demux: Seen another BOS on stream" << std::endl
;
214 //Complain about any gaps in stream.
215 bool gap
= seen_page
&& complain_lost_page(sequence
, stream
);
216 //Complain about continuation errors.
218 flags
|= continued
? 1 : 0;
219 flags
|= bos
? 2 : 0;
220 flags
|= eos
? 4 : 0;
221 flags
|= incomplete
? 8 : 0;
222 flags
|= damaged_packet
? 16 : 0;
223 flags
|= gap
? 32 : 0;
224 flags
|= !partial
.empty() ? 64 : 0;
225 complain_continue_errors(flags
, sequence
, stream
, pkts
, granulepos
);
227 if(pkts
== 1 && incomplete
) {
228 //Nothing finishes on this page either.
229 auto frag
= p
.get_packet(0);
230 newbuffer
.resize(partial
.size() + frag
.second
);
231 memcpy(&newbuffer
[0], &partial
[0], partial
.size());
232 memcpy(&newbuffer
[partial
.size()], frag
.first
, frag
.second
);
233 std::swap(newbuffer
, partial
);
234 damaged_packet
= damaged_packet
|| gap
;
236 imprint_stream
= stream
;
237 update_pageseq(sequence
);
239 if(granulepos
!= page::granulepos_none
)
240 last_granulepos
= granulepos
;
242 } else if(pkts
== 2 && incomplete
&& (partial
.empty() || damaged_packet
|| gap
)) {
243 //The first packet is busted and the second is incomplete. Load the rest.
244 auto frag
= p
.get_packet(1);
245 newbuffer
.resize(frag
.second
);
246 memcpy(&newbuffer
[0], frag
.first
, frag
.second
);
247 std::swap(newbuffer
, partial
);
249 imprint_stream
= stream
;
250 update_pageseq(sequence
);
251 damaged_packet
= false;
255 if(granulepos
!= page::granulepos_none
)
256 last_granulepos
= granulepos
;
260 dpacket
= (continued
&& (partial
.empty() || damaged_packet
|| gap
)) ? 1 : 0; //Busted?
265 damaged_packet
= false;
267 imprint_stream
= stream
;
268 update_pageseq(sequence
);
270 if(granulepos
!= page::granulepos_none
)
271 last_granulepos
= granulepos
;
275 void demuxer::packet_out(ogg::packet
& pkt
)
277 if(!wants_packet_out())
278 throw std::runtime_error("Not ready for packet");
279 bool firstfrag
= (dpacket
== 0 && last_page
.get_continue());
280 bool lastfrag
= (dpacket
== packets
- 1 && last_page
.get_last_packet_incomplete());
282 //Wholly on this page.
283 std::vector
<uint8_t> newbuffer
;
284 auto frag
= last_page
.get_packet(dpacket
);
285 newbuffer
.resize(frag
.second
);
286 memcpy(&newbuffer
[0], frag
.first
, frag
.second
);
287 pkt
= packet(last_page
.get_granulepos(), dpacket
== 0, (dpacket
== packets
- 1), false,
288 last_page
.get_eos(), last_page
.get_bos(), newbuffer
);
290 //Continued from the last page.
291 std::vector
<uint8_t> newbuffer
;
292 auto frag
= last_page
.get_packet(0);
293 newbuffer
.resize(partial
.size() + frag
.second
);
294 memcpy(&newbuffer
[0], &partial
[0], partial
.size());
295 memcpy(&newbuffer
[partial
.size()], frag
.first
, frag
.second
);
296 pkt
= packet(last_page
.get_granulepos(), true, (packets
== 1), true, last_page
.get_eos(),
297 started_bos
, newbuffer
);
300 //Load the next packet fragment
301 auto frag2
= last_page
.get_packet(dpacket
+ 1);
302 std::vector
<uint8_t> newbuffer
;
303 newbuffer
.resize(frag2
.second
);
304 memcpy(&newbuffer
[0], frag2
.first
, frag2
.second
);
305 std::swap(newbuffer
, partial
);
306 started_bos
= last_page
.get_bos();
311 void demuxer::discard_packet()
313 if(!wants_packet_out())
314 throw std::runtime_error("Not ready for packet");
315 bool lastfrag
= (dpacket
== packets
- 1 && last_page
.get_last_packet_incomplete());
317 //Load the next packet fragment
318 auto frag2
= last_page
.get_packet(dpacket
+ 1);
319 std::vector
<uint8_t> newbuffer
;
320 newbuffer
.resize(frag2
.second
);
321 memcpy(&newbuffer
[0], frag2
.first
, frag2
.second
);
322 std::swap(newbuffer
, partial
);
327 muxer::muxer(uint32_t streamid
, uint64_t _seq
)
331 eos_asserted
= false;
333 granulepos
= page::granulepos_none
;
334 buffer
.set_granulepos(page::granulepos_none
);
338 bool muxer::packet_fits(size_t pktsize
) const throw()
340 return pktsize
<= buffer
.get_max_complete_packet();
343 bool muxer::wants_packet_in() const throw()
345 return buffered
.size() == written
&& !eos_asserted
;
348 bool muxer::has_page_out() const throw()
350 return buffer
.get_packet_count() > 0;
353 void muxer::signal_eos()
358 void muxer::packet_in(const std::vector
<uint8_t>& data
, uint64_t granule
)
360 if(!wants_packet_in() || eos_asserted
)
361 throw std::runtime_error("Muxer not ready for packet");
364 const uint8_t* _data
= &data
[0];
365 size_t _len
= data
.size();
366 bool r
= buffer
.append_packet_incomplete(_data
, _len
);
368 written
= data
.size();
369 buffer
.set_granulepos(granule
);
370 return; //Complete write.
372 granulepos
= granule
;
373 written
= data
.size() - _len
;
376 void muxer::page_out(page
& p
)
379 throw std::runtime_error("Muxer not ready for page");
380 if(eos_asserted
&& written
== buffered
.size())
381 buffer
.set_eos(true); //This is the end.
382 buffer
.set_bos(seq
== 0);
383 buffer
.set_sequence(seq
);
384 buffer
.set_stream(strmid
);
388 //Now we have a fresh page, flush buffer there.
389 if(written
< buffered
.size()) {
390 const uint8_t* _data
= &buffered
[written
];
391 size_t _len
= buffered
.size() - written
;
392 bool r
= buffer
.append_packet_incomplete(_data
, _len
);
394 written
= buffered
.size();
395 buffer
.set_granulepos(granulepos
);
396 buffer
.set_continue(written
!= 0);
397 granulepos
= page::granulepos_none
;
400 written
= buffered
.size() - _len
;
402 buffer
.set_granulepos(page::granulepos_none
);
408 flag_continue
= false;
411 last_incomplete
= false;
412 granulepos
= granulepos_none
;
418 memset(data
, 0, sizeof(data
));
419 memset(segments
, 0, sizeof(segments
));
420 memset(packets
, 0, sizeof(packets
));
423 page::page(const char* buffer
, size_t& advance
) throw(std::runtime_error
)
425 //Check validity of page header.
426 if(buffer
[0] != 'O' || buffer
[1] != 'g' || buffer
[2] != 'g' || buffer
[3] != 'S')
427 throw std::runtime_error("Bad Ogg page header");
429 throw std::runtime_error("Bad Ogg page version");
431 throw std::runtime_error("Bad Ogg page flags");
433 size_t b
= 27 + (unsigned char)buffer
[26];
435 for(unsigned i
= 0; i
< (unsigned char)buffer
[26]; i
++) {
436 b
+= (unsigned char)buffer
[27 + i
];
437 data_count
+= (unsigned char)buffer
[27 + i
];
440 uint32_t claimed
= serialization::u32l(buffer
+ 22);
442 uint32_t actual
= oggcrc32(0, NULL
, 0);
443 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(buffer
), 22);
444 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(&x
), 4);
445 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(buffer
+ 26), b
- 26);
446 if(claimed
!= actual
)
447 throw std::runtime_error("Bad Ogg page checksum");
448 //This packet is valid.
450 uint8_t flags
= buffer
[5];
451 flag_continue
= (flags
& 1);
452 flag_bos
= (flags
& 2);
453 flag_eos
= (flags
& 4);
454 granulepos
= serialization::u64l(buffer
+ 6);
455 stream
= serialization::u32l(buffer
+ 14);
456 sequence
= serialization::u32l(buffer
+ 18);
457 segment_count
= buffer
[26];
458 memset(segments
, 0, sizeof(segments
));
460 memcpy(segments
, buffer
+ 27, segment_count
);
461 memset(data
, 0, sizeof(data
));
462 if(b
> 27U + segment_count
)
463 memcpy(data
, buffer
+ 27 + segment_count
, b
- 27 - segment_count
);
465 memset(packets
, 0, sizeof(packets
));
466 if(segment_count
> 0)
467 packets
[packet_count
++] = 0;
469 for(unsigned i
= 0; i
< segment_count
; i
++) {
471 if(segment_count
> i
+ 1 && segments
[i
] < 255)
472 packets
[packet_count
++] = dptr
;
474 packets
[packet_count
] = dptr
;
475 last_incomplete
= (!flag_eos
&& segment_count
> 0 && segments
[segment_count
- 1] == 255);
479 bool page::scan(const char* buffer
, size_t bufferlen
, bool eof
, size_t& advance
) throw()
481 const char* _buffer
= buffer
;
482 size_t buffer_left
= bufferlen
;
484 while(buffer_left
>= 27) {
485 //Check capture pattern.
486 if(_buffer
[0] != 'O' || _buffer
[1] != 'g' || _buffer
[2] != 'g' || _buffer
[3] != 'S') {
492 //Check that version is valid.
493 if(_buffer
[4] != 0) {
499 //Check that flags are valid.
500 if(_buffer
[5] & 0xF8) {
506 //Check that segment table is present. If not, more data can uncover a page here.
507 if(27U + (unsigned char)_buffer
[26] > buffer_left
) {
517 //Check that all data is there. If not, more data can uncover a page here.
518 size_t b
= 27 + (unsigned char)_buffer
[26];
519 for(unsigned i
= 0; i
< (unsigned char)_buffer
[26]; i
++)
520 b
+= (unsigned char)_buffer
[27 + i
];
521 if(b
> buffer_left
) {
532 uint32_t claimed
= serialization::u32l(_buffer
+ 22);
534 uint32_t actual
= oggcrc32(0, NULL
, 0);
535 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(_buffer
), 22);
536 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(&x
), 4);
537 actual
= oggcrc32(actual
, reinterpret_cast<const uint8_t*>(_buffer
+ 26), b
- 26);
538 if(claimed
!= actual
) {
539 //CRC check fails. Advance.
545 return true; //Here is a packet.
547 if(eof
&& buffer_left
< 27) {
548 //Advance to the end.
549 advance
+= buffer_left
;
554 std::string
page::stream_debug_id() const throw(std::bad_alloc
)
556 return (stringfmt() << "Stream " << hex::to(stream
)).str();
559 std::string
page::page_debug_id() const throw(std::bad_alloc
)
561 return (stringfmt() << stream_debug_id() << " page " << sequence
).str();
564 size_t page::get_max_complete_packet() const throw()
566 if(segment_count
== 255)
568 return (255 - segment_count
) * 255 - 1;
571 bool page::append_packet(const uint8_t* _data
, size_t datalen
) throw()
573 //Compute the smallest amount of data we can't write.
574 size_t imin
= (255 - segment_count
) * 255;
576 return false; //Can't write.
577 //Okay, it fits. Write.
578 packets
[packet_count
++] = data_count
;
579 bool terminate
= false;
582 segments
[segment_count
++] = 255;
583 memcpy(data
+ data_count
, _data
, 255);
588 segments
[segment_count
++] = datalen
;
589 memcpy(data
+ data_count
, _data
, datalen
);
590 data_count
+= datalen
;
597 segments
[segment_count
++] = 0;
598 packets
[packet_count
] = data_count
;
599 last_incomplete
= false;
603 bool page::append_packet_incomplete(const uint8_t*& _data
, size_t& datalen
) throw()
605 //If we have absolutely no space, don't flag a packet.
606 if(segment_count
== 255)
608 packets
[packet_count
++] = data_count
;
609 //Append segments, one by one.
610 while(segment_count
< 255) {
612 segments
[segment_count
++] = 255;
613 memcpy(data
+ data_count
, _data
, 255);
618 //Final segment of packet.
619 segments
[segment_count
++] = datalen
;
620 memcpy(data
+ data_count
, _data
, datalen
);
621 data_count
+= datalen
;
624 packets
[packet_count
] = data_count
;
625 last_incomplete
= false;
629 packets
[packet_count
] = data_count
;
630 last_incomplete
= true;
634 void page::serialize(char* buffer
) const throw()
636 memcpy(buffer
, "OggS", 4);
638 buffer
[5] = (flag_continue
? 1 : 0) | (flag_bos
? 2 : 0) | (flag_eos
? 4 : 0);
639 serialization::u64l(buffer
+ 6, granulepos
);
640 serialization::u32l(buffer
+ 14, stream
);
641 serialization::u32l(buffer
+ 18, sequence
);
642 serialization::u32l(buffer
+ 22, 0); //CRC will be fixed later.
643 buffer
[26] = segment_count
;
644 memcpy(buffer
+ 27, segments
, segment_count
);
645 memcpy(buffer
+ 27 + segment_count
, data
, data_count
);
646 size_t plen
= 27 + segment_count
+ data_count
;
648 serialization::u32l(buffer
+ 22, oggcrc32(oggcrc32(0, NULL
, 0), reinterpret_cast<uint8_t*>(buffer
), plen
));
651 const uint64_t page::granulepos_none
= 0xFFFFFFFFFFFFFFFFULL
;
655 stream_reader::stream_reader() throw()
659 errors_to
= &std::cerr
;
664 stream_reader::~stream_reader() throw()
668 void stream_reader::set_errors_to(std::ostream
& os
)
673 bool stream_reader::get_page(page
& spage
) throw(std::exception
)
681 f
= page::scan(buffer
, left
, eof
, advance
);
683 //The ogg stream resyncs.
684 (*errors_to
) << "Warning: Ogg stream: Recapture after " << advance
<< " bytes." << std::endl
;
685 discard_buffer(advance
);
690 spage
= page(buffer
, advance
);
691 last_offset
= start_offset
;
692 discard_buffer(advance
);
696 void stream_reader::fill_buffer()
699 if(!eof
&& left
< sizeof(buffer
)) {
700 left
+= (r
= read(buffer
+ left
, sizeof(buffer
) - left
));
706 void stream_reader::discard_buffer(size_t amount
)
709 memmove(buffer
, buffer
+ amount
, left
- amount
);
711 start_offset
+= amount
;
714 stream_writer::stream_writer() throw()
718 stream_writer::~stream_writer() throw()
722 void stream_writer::put_page(const page
& page
) throw(std::exception
)
725 size_t s
= page
.serialize_size();
726 page
.serialize(buffer
);
730 stream_reader_iostreams::stream_reader_iostreams(std::istream
& stream
)
735 stream_reader_iostreams::~stream_reader_iostreams() throw()
739 size_t stream_reader_iostreams::read(char* buffer
, size_t size
) throw(std::exception
)
743 is
.read(buffer
, size
);
747 stream_writer_iostreams::stream_writer_iostreams(std::ostream
& stream
)
752 stream_writer_iostreams::~stream_writer_iostreams() throw()
756 void stream_writer_iostreams::write(const char* buffer
, size_t size
) throw(std::exception
)
759 throw std::runtime_error("Error writing data");
760 os
.write(buffer
, size
);
762 throw std::runtime_error("Error writing data");