src/library/ogg.cpp

   1 #include "ogg.hpp"
   2 #include "serialization.hpp"
   3 #include "minmax.hpp"
   4 #include <cstring>
   5 #include <zlib.h>
   6 #include <algorithm>
   7 #include <iostream>
   8 #include <iomanip>
   9 #include "string.hpp"
  10
  11 namespace {
  12         const uint32_t crc_lookup[256]= {
  13                 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
  14                 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
  15                 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
  16                 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
  17                 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
  18                 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
  19                 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
  20                 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
  21                 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
  22                 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
  23                 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
  24                 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
  25                 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
  26                 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
  27                 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
  28                 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
  29                 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
  30                 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
  31                 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
  32                 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
  33                 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
  34                 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
  35                 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
  36                 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
  37                 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
  38                 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
  39                 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
  40                 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
  41                 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
  42                 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
  43                 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
  44                 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
  45                 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
  46                 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
  47                 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
  48                 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
  49                 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
  50                 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
  51                 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
  52                 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
  53                 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
  54                 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
  55                 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
  56                 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
  57                 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
  58                 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
  59                 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
  60                 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
  61                 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
  62                 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
  63                 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
  64                 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
  65                 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
  66                 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
  67                 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
  68                 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
  69                 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
  70                 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
  71                 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
  72                 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
  73                 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
  74                 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
  75                 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
  76                 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4
  77         };
  78
  79         uint32_t ogg_crc32(uint32_t chain, const uint8_t* data, size_t size)
  80         {
  81                 if(!data)
  82                         return 0;
  83                 for(size_t i = 0; i < size; i++)
  84                         chain = (chain << 8) ^ crc_lookup[(chain >> 24) ^ data[i]];
  85                 return chain;
  86         }
  87 }
  88
  89
  90 ogg_packet::ogg_packet(uint64_t granule, bool first, bool last, bool spans, bool eos, bool bos,
  91         const std::vector<uint8_t>& d)
  92 {
  93         data = d;
  94         granulepos = granule;
  95         first_page = first;
  96         last_page = last;
  97         spans_page = spans;
  98         eos_page = eos;
  99         bos_page = bos;
 100 }
 101
 102 ogg_demuxer::ogg_demuxer(std::ostream& _errors_to)
 103         : errors_to(_errors_to)
 104 {
 105         seen_page = false;
 106         imprint_stream = 0;
 107         page_seq = 0;
 108         page_era = 0;
 109         packet = 0;
 110         packets = 0;
 111         ended = false;
 112         damaged_packet = false;
 113         last_granulepos = 0;
 114 }
 115
 116 uint64_t ogg_demuxer::page_fullseq(uint32_t seq)
 117 {
 118         if(seq < page_seq)
 119                 return (static_cast<uint64_t>(page_era + 1) << 32) + seq;
 120         else
 121                 return (static_cast<uint64_t>(page_era) << 32) + seq;
 122 }
 123
 124 void ogg_demuxer::update_pageseq(uint32_t new_seq)
 125 {
 126         if(new_seq < page_seq)
 127                 page_era++;
 128         page_seq = new_seq;
 129 }
 130
 131 bool ogg_demuxer::complain_lost_page(uint32_t new_seq, uint32_t stream)
 132 {
 133         if(new_seq != static_cast<uint32_t>(page_seq + 1)) {
 134                 //Some pages are missing!
 135                 uint64_t first_missing = page_fullseq(page_seq) + 1;
 136                 uint64_t last_missing = page_fullseq(new_seq) - 1;
 137                 if(first_missing == last_missing)
 138                         errors_to << "Warning: Ogg demux: Page " << first_missing << " missing on stream "
 139                                 << (stringfmt() << std::hex << std::setw(8) << std::setfill('0') << stream).str()
 140                                 << std::endl;
 141                 else
 142                         errors_to << "Warning: Ogg demux: Pages " << first_missing << "-" << last_missing
 143                                 << " missing on stream " << (stringfmt() << std::hex << std::setw(8)
 144                                 << std::setfill('0') << stream).str() << std::endl;
 145                 return true;
 146         }
 147         return false;
 148 }
 149
 150 void ogg_demuxer::complain_continue_errors(unsigned flags, uint32_t seqno, uint32_t stream, uint32_t pkts,
 151         uint64_t granule)
 152 {
 153         bool continued = (flags & 1);
 154         bool bos = (flags & 2);
 155         bool eos = (flags & 4);
 156         bool incomplete = (flags & 8);
 157         bool damaged = (flags & 16);
 158         bool gap = (flags & 32);
 159         bool data = (flags & 64);
 160         if(!continued) {
 161                 if(data && !damaged && !gap)
 162                         errors_to << "Warning: Ogg demux: Data spilled from previous page but not continued (page "
 163                                 << page_fullseq(seqno) << " of " << stream << ")" << std::endl;
 164                 if(data && !damaged && gap)
 165                         errors_to << "Warning: Ogg demux: Packet continues to lost page" << std::endl;
 166         } else {
 167                 if(bos)
 168                         errors_to << "Warning: Ogg demux: BOS page has CONTINUED set (stream " << stream << ")."
 169                                 << std::endl;
 170                 else if(!data && !damaged && !gap)
 171                         errors_to << "Warning: Ogg demux: No Data spilled from previous page but continued (page "
 172                                 << page_fullseq(seqno) << " of " << stream << ")" << std::endl;
 173                 if(data && !damaged && gap)
 174                         errors_to << "Warning: Ogg demux: Packet continues to/from lost page" << std::endl;
 175                 if(!data && !damaged && gap)
 176                         errors_to << "Warning: Ogg demux: Packet continues from lost page" << std::endl;
 177         }
 178         if(incomplete && eos)
 179                 errors_to << "Warning: Ogg demux: EOS page with incomplete packet (stream " << stream << ")."
 180                         << std::endl;
 181         if(incomplete && pkts == 1 && granule != ogg_page::granulepos_none)
 182                 errors_to << "Warning: Ogg demux: Page should have granulepos NONE (page " << page_fullseq(seqno)
 183                         << " of " << stream << ")" << std::endl;
 184         if((!incomplete || pkts > 1) && granule == ogg_page::granulepos_none)
 185                 errors_to << "Warning: Ogg demux: Page should not have granulepos NONE (page " << page_fullseq(seqno)
 186                         << " of " << stream << ")" << std::endl;
 187 }
 188
 189 bool ogg_demuxer::page_in(const ogg_page& p)
 190 {
 191         //Is this from the right stream? If not, ignore page.
 192         uint32_t stream = p.get_stream();
 193         if(seen_page && stream != imprint_stream)
 194                 return false;           //Wrong stream.
 195         if(!wants_page_in())
 196                 throw std::runtime_error("Not ready for page");
 197         std::vector<uint8_t> newbuffer;
 198         uint32_t sequence = p.get_sequence();
 199         uint32_t pkts = p.get_packet_count();
 200         uint64_t granulepos = p.get_granulepos();
 201         bool bos = p.get_bos();
 202         bool eos = p.get_eos();
 203         bool continued = p.get_continue();
 204         bool incomplete = p.get_last_packet_incomplete();
 205         //BOS flag can only be set on first page.
 206         if(granulepos < last_granulepos && granulepos != ogg_page::granulepos_none)
 207                 errors_to << "Warning: Ogg demux: Non-monotonic granulepos" << std::endl;
 208         if(!seen_page && !bos)
 209                 errors_to << "Warning: Ogg demux: First page does not have BOS set." << std::endl;
 210         if(seen_page && bos)
 211                 errors_to << "Warning: Ogg demux: Seen another BOS on stream" << std::endl;
 212         //Complain about any gaps in stream.
 213         bool gap = seen_page && complain_lost_page(sequence, stream);
 214         //Complain about continuation errors.
 215         unsigned flags = 0;
 216         flags |= continued ? 1 : 0;
 217         flags |= bos ? 2 : 0;
 218         flags |= eos ? 4 : 0;
 219         flags |= incomplete ? 8 : 0;
 220         flags |= damaged_packet ? 16 : 0;
 221         flags |= gap ? 32 : 0;
 222         flags |= !partial.empty() ? 64 : 0;
 223         complain_continue_errors(flags, sequence, stream, pkts, granulepos);
 224         if(continued) {
 225                 if(pkts == 1 && incomplete) {
 226                         //Nothing finishes on this page either.
 227                         auto frag = p.get_packet(0);
 228                         newbuffer.resize(partial.size() + frag.second);
 229                         memcpy(&newbuffer[0], &partial[0], partial.size());
 230                         memcpy(&newbuffer[partial.size()], frag.first, frag.second);
 231                         std::swap(newbuffer, partial);
 232                         damaged_packet = damaged_packet || gap;
 233                         seen_page = true;
 234                         imprint_stream = stream;
 235                         update_pageseq(sequence);
 236                         ended = eos;
 237                         if(granulepos != ogg_page::granulepos_none)
 238                                 last_granulepos = granulepos;
 239                         return true;
 240                 } else if(pkts == 2 && incomplete && (partial.empty() || damaged_packet || gap)) {
 241                         //The first packet is busted and the second is incomplete. Load the rest.
 242                         auto frag = p.get_packet(1);
 243                         newbuffer.resize(frag.second);
 244                         memcpy(&newbuffer[0], frag.first, frag.second);
 245                         std::swap(newbuffer, partial);
 246                         seen_page = true;
 247                         imprint_stream = stream;
 248                         update_pageseq(sequence);
 249                         damaged_packet = false;
 250                         ended = eos;
 251                         packet = 1;
 252                         packets = 1;
 253                         if(granulepos != ogg_page::granulepos_none)
 254                                 last_granulepos = granulepos;
 255                         return true;
 256                 }
 257         }
 258         packet = (continued && (partial.empty() || damaged_packet || gap)) ? 1 : 0;     //Busted?
 259         packets = pkts;
 260         if(incomplete)
 261                 packets--;
 262         last_page = p;
 263         damaged_packet = false;
 264         seen_page = true;
 265         imprint_stream = stream;
 266         update_pageseq(sequence);
 267         ended = eos;
 268         if(granulepos != ogg_page::granulepos_none)
 269                 last_granulepos = granulepos;
 270         return true;
 271 }
 272
 273 void ogg_demuxer::packet_out(ogg_packet& pkt)
 274 {
 275         if(!wants_packet_out())
 276                 throw std::runtime_error("Not ready for packet");
 277         bool firstfrag = (packet == 0 && last_page.get_continue());
 278         bool lastfrag = (packet == packets - 1 && last_page.get_last_packet_incomplete());
 279         if(!firstfrag) {
 280                 //Wholly on this page.
 281                 std::vector<uint8_t> newbuffer;
 282                 auto frag = last_page.get_packet(packet);
 283                 newbuffer.resize(frag.second);
 284                 memcpy(&newbuffer[0], frag.first, frag.second);
 285                 pkt = ogg_packet(last_page.get_granulepos(), packet == 0, (packet == packets - 1), false,
 286                         last_page.get_eos(), last_page.get_bos(), newbuffer);
 287         } else {
 288                 //Continued from the last page.
 289                 std::vector<uint8_t> newbuffer;
 290                 auto frag = last_page.get_packet(0);
 291                 newbuffer.resize(partial.size() + frag.second);
 292                 memcpy(&newbuffer[0], &partial[0], partial.size());
 293                 memcpy(&newbuffer[partial.size()], frag.first, frag.second);
 294                 pkt = ogg_packet(last_page.get_granulepos(), true, (packets == 1), true, last_page.get_eos(),
 295                         started_bos, newbuffer);
 296         }
 297         if(lastfrag) {
 298                 //Load the next packet fragment
 299                 auto frag2 = last_page.get_packet(packet + 1);
 300                 std::vector<uint8_t> newbuffer;
 301                 newbuffer.resize(frag2.second);
 302                 memcpy(&newbuffer[0], frag2.first, frag2.second);
 303                 std::swap(newbuffer, partial);
 304                 started_bos = last_page.get_bos();
 305         }
 306         packet++;
 307 }
 308
 309 void ogg_demuxer::discard_packet()
 310 {
 311         if(!wants_packet_out())
 312                 throw std::runtime_error("Not ready for packet");
 313         bool lastfrag = (packet == packets - 1 && last_page.get_last_packet_incomplete());
 314         if(lastfrag) {
 315                 //Load the next packet fragment
 316                 auto frag2 = last_page.get_packet(packet + 1);
 317                 std::vector<uint8_t> newbuffer;
 318                 newbuffer.resize(frag2.second);
 319                 memcpy(&newbuffer[0], frag2.first, frag2.second);
 320                 std::swap(newbuffer, partial);
 321         }
 322         packet++;
 323 }
 324
 325 ogg_muxer::ogg_muxer(uint32_t streamid, uint64_t _seq)
 326 {
 327         strmid = streamid;
 328         written = 0;
 329         eos_asserted = false;
 330         seq = _seq;
 331         granulepos = ogg_page::granulepos_none;
 332         buffer.set_granulepos(ogg_page::granulepos_none);
 333 }
 334
 335
 336 bool ogg_muxer::packet_fits(size_t pktsize) const throw()
 337 {
 338         return pktsize <= buffer.get_max_complete_packet();
 339 }
 340
 341 bool ogg_muxer::wants_packet_in() const throw()
 342 {
 343         return buffered.size() == written && !eos_asserted;
 344 }
 345
 346 bool ogg_muxer::has_page_out() const throw()
 347 {
 348         return buffer.get_packet_count() > 0;
 349 }
 350
 351 void ogg_muxer::signal_eos()
 352 {
 353         eos_asserted = true;
 354 }
 355
 356 void ogg_muxer::packet_in(const std::vector<uint8_t>& data, uint64_t granule)
 357 {
 358         if(!wants_packet_in() || eos_asserted)
 359                 throw std::runtime_error("Muxer not ready for packet");
 360         buffered = data;
 361         //Try direct write.
 362         const uint8_t* _data = &data[0];
 363         size_t _len = data.size();
 364         bool r = buffer.append_packet_incomplete(_data, _len);
 365         if(r) {
 366                 written = data.size();
 367                 buffer.set_granulepos(granule);
 368                 return;         //Complete write.
 369         }
 370         granulepos = granule;
 371         written = data.size() - _len;
 372 }
 373
 374 void ogg_muxer::page_out(ogg_page& p)
 375 {
 376         if(!has_page_out())
 377                 throw std::runtime_error("Muxer not ready for page");
 378         if(eos_asserted && written == buffered.size())
 379                 buffer.set_eos(true);   //This is the end.
 380         buffer.set_bos(seq == 0);
 381         buffer.set_sequence(seq);
 382         buffer.set_stream(strmid);
 383         p = buffer;
 384         buffer = ogg_page();
 385         seq++;
 386         //Now we have a fresh page, flush buffer there.
 387         if(written < buffered.size()) {
 388                 const uint8_t* _data = &buffered[written];
 389                 size_t _len = buffered.size() - written;
 390                 bool r = buffer.append_packet_incomplete(_data, _len);
 391                 if(r) {
 392                         written = buffered.size();
 393                         buffer.set_granulepos(granulepos);
 394                         buffer.set_continue(written != 0);
 395                         granulepos = ogg_page::granulepos_none;
 396                         return;
 397                 }
 398                 written = buffered.size() - _len;
 399         }
 400         buffer.set_granulepos(ogg_page::granulepos_none);
 401 }
 402
 403 ogg_page::ogg_page() throw()
 404 {
 405         version = 0;
 406         flag_continue = false;
 407         flag_bos = false;
 408         flag_eos = false;
 409         last_incomplete = false;
 410         granulepos = granulepos_none;
 411         stream = 0;
 412         sequence = 0;
 413         segment_count = 0;
 414         packet_count = 0;
 415         data_count = 0;
 416         memset(data, 0, sizeof(data));
 417         memset(segments, 0, sizeof(segments));
 418         memset(packets, 0, sizeof(packets));
 419 }
 420
 421 ogg_page::ogg_page(const char* buffer, size_t& advance) throw(std::runtime_error)
 422 {
 423         //Check validity of page header.
 424         if(buffer[0] != 'O' || buffer[1] != 'g' || buffer[2] != 'g' || buffer[3] != 'S')
 425                 throw std::runtime_error("Bad Ogg page header");
 426         if(buffer[4] != 0)
 427                 throw std::runtime_error("Bad Ogg page version");
 428         if(buffer[5] & 0xF8)
 429                 throw std::runtime_error("Bad Ogg page flags");
 430         //Compute length.
 431         size_t b = 27 + (unsigned char)buffer[26];
 432         data_count = 0;
 433         for(unsigned i = 0; i < (unsigned char)buffer[26]; i++) {
 434                 b += (unsigned char)buffer[27 + i];
 435                 data_count += (unsigned char)buffer[27 + i];
 436         }
 437         //Check the CRC.
 438         uint32_t claimed = read32ule(buffer + 22);
 439         uint32_t x = 0;
 440         uint32_t actual = ogg_crc32(0, NULL, 0);
 441         actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(buffer), 22);
 442         actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(&x), 4);
 443         actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(buffer + 26), b - 26);
 444         if(claimed != actual)
 445                 throw std::runtime_error("Bad Ogg page checksum");
 446         //This packet is valid.
 447         version = buffer[4];
 448         uint8_t flags = buffer[5];
 449         flag_continue = (flags & 1);
 450         flag_bos = (flags & 2);
 451         flag_eos = (flags & 4);
 452         granulepos = read64ule(buffer + 6);
 453         stream = read32ule(buffer + 14);
 454         sequence = read32ule(buffer + 18);
 455         segment_count = buffer[26];
 456         memset(segments, 0, sizeof(segments));
 457         if(segment_count)
 458                 memcpy(segments, buffer + 27, segment_count);
 459         memset(data, 0, sizeof(data));
 460         if(b > 27U + segment_count)
 461                 memcpy(data, buffer + 27 + segment_count, b - 27 - segment_count);
 462         packet_count = 0;
 463         memset(packets, 0, sizeof(packets));
 464         if(segment_count > 0)
 465                 packets[packet_count++] = 0;
 466         uint16_t dptr = 0;
 467         for(unsigned i = 0; i < segment_count; i++) {
 468                 dptr += segments[i];
 469                 if(segment_count > i + 1 && segments[i] < 255)
 470                         packets[packet_count++] = dptr;
 471         }
 472         packets[packet_count] = dptr;
 473         last_incomplete = (!flag_eos && segment_count > 0 && segments[segment_count - 1] == 255);
 474         advance = b;
 475 }
 476
 477 bool ogg_page::scan(const char* buffer, size_t bufferlen, bool eof, size_t& advance) throw()
 478 {
 479         const char* _buffer = buffer;
 480         size_t buffer_left = bufferlen;
 481         advance = 0;
 482         while(buffer_left >= 27) {
 483                 //Check capture pattern.
 484                 if(_buffer[0] != 'O' || _buffer[1] != 'g' || _buffer[2] != 'g' || _buffer[3] != 'S') {
 485                         advance++;
 486                         _buffer++;
 487                         buffer_left--;
 488                         continue;
 489                 }
 490                 //Check that version is valid.
 491                 if(_buffer[4] != 0) {
 492                         advance++;
 493                         _buffer++;
 494                         buffer_left--;
 495                         continue;
 496                 }
 497                 //Check that flags are valid.
 498                 if(_buffer[5] & 0xF8) {
 499                         advance++;
 500                         _buffer++;
 501                         buffer_left--;
 502                         continue;
 503                 }
 504                 //Check that segment table is present. If not, more data can uncover a page here.
 505                 if(27U + (unsigned char)_buffer[26] > buffer_left) {
 506                         if(!eof) {
 507                                 return false;
 508                         } else {
 509                                 advance++;
 510                                 _buffer++;
 511                                 buffer_left--;
 512                                 continue;
 513                         }
 514                 }
 515                 //Check that all data is there. If not, more data can uncover a page here.
 516                 size_t b = 27 + (unsigned char)_buffer[26];
 517                 for(unsigned i = 0; i < (unsigned char)_buffer[26]; i++)
 518                         b += (unsigned char)_buffer[27 + i];
 519                 if(b > buffer_left) {
 520                         if(!eof) {
 521                                 return false;
 522                         } else {
 523                                 advance++;
 524                                 _buffer++;
 525                                 buffer_left--;
 526                                 continue;
 527                         }
 528                 }
 529                 //Check the CRC.
 530                 uint32_t claimed = read32ule(_buffer + 22);
 531                 uint32_t x = 0;
 532                 uint32_t actual = ogg_crc32(0, NULL, 0);
 533                 actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(_buffer), 22);
 534                 actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(&x), 4);
 535                 actual = ogg_crc32(actual, reinterpret_cast<const uint8_t*>(_buffer + 26), b - 26);
 536                 if(claimed != actual) {
 537                         //CRC check fails. Advance.
 538                         advance++;
 539                         _buffer++;
 540                         buffer_left--;
 541                         continue;
 542                 }
 543                 return true;    //Here is a packet.
 544         }
 545         if(eof && buffer_left < 27) {
 546                 //Advance to the end.
 547                 advance += buffer_left;
 548         }
 549         return false;
 550 }
 551
 552 std::string ogg_page::stream_debug_id() const throw(std::bad_alloc)
 553 {
 554         return (stringfmt() << "Stream " << std::hex << std::setfill('0') << std::setw(8) << stream).str();
 555 }
 556
 557 std::string ogg_page::page_debug_id() const throw(std::bad_alloc)
 558 {
 559         return (stringfmt() << stream_debug_id() << " page " << sequence).str();
 560 }
 561
 562 size_t ogg_page::get_max_complete_packet() const throw()
 563 {
 564         if(segment_count == 255)
 565                 return 0;
 566         return (255 - segment_count) * 255 - 1;
 567 }
 568
 569 bool ogg_page::append_packet(const uint8_t* _data, size_t datalen) throw()
 570 {
 571         //Compute the smallest amount of data we can't write.
 572         size_t imin = (255 - segment_count) * 255;
 573         if(datalen >= imin)
 574                 return false;           //Can't write.
 575         //Okay, it fits. Write.
 576         packets[packet_count++] = data_count;
 577         bool terminate = false;
 578         while(datalen > 0) {
 579                 if(datalen >= 255) {
 580                         segments[segment_count++] = 255;
 581                         memcpy(data + data_count, _data, 255);
 582                         data_count += 255;
 583                         _data += 255;
 584                         datalen -= 255;
 585                 } else {
 586                         segments[segment_count++] = datalen;
 587                         memcpy(data + data_count, _data, datalen);
 588                         data_count += datalen;
 589                         _data += datalen;
 590                         datalen = 0;
 591                         terminate = true;
 592                 }
 593         }
 594         if(!terminate)
 595                 segments[segment_count++] = 0;
 596         packets[packet_count] = data_count;
 597         last_incomplete = false;
 598         return true;
 599 }
 600
 601 bool ogg_page::append_packet_incomplete(const uint8_t*& _data, size_t& datalen) throw()
 602 {
 603         //If we have absolutely no space, don't flag a packet.
 604         if(segment_count == 255)
 605                 return false;
 606         packets[packet_count++] = data_count;
 607         //Append segments, one by one.
 608         while(segment_count < 255) {
 609                 if(datalen >= 255) {
 610                         segments[segment_count++] = 255;
 611                         memcpy(data + data_count, _data, 255);
 612                         data_count += 255;
 613                         _data += 255;
 614                         datalen -= 255;
 615                 } else {
 616                         //Final segment of packet.
 617                         segments[segment_count++] = datalen;
 618                         memcpy(data + data_count, _data, datalen);
 619                         data_count += datalen;
 620                         _data += datalen;
 621                         datalen = 0;
 622                         packets[packet_count] = data_count;
 623                         last_incomplete = false;
 624                         return true;
 625                 }
 626         }
 627         packets[packet_count] = data_count;
 628         last_incomplete = true;
 629         return false;
 630 }
 631
 632 void ogg_page::serialize(char* buffer) const throw()
 633 {
 634         memcpy(buffer, "OggS", 4);
 635         buffer[4] = version;
 636         buffer[5] = (flag_continue ? 1 : 0) | (flag_bos ? 2 : 0) | (flag_eos ? 4 : 0);
 637         write64ule(buffer + 6, granulepos);
 638         write32ule(buffer + 14, stream);
 639         write32ule(buffer + 18, sequence);
 640         write32ule(buffer + 22, 0);     //CRC will be fixed later.
 641         buffer[26] = segment_count;
 642         memcpy(buffer + 27, segments, segment_count);
 643         memcpy(buffer + 27 + segment_count, data, data_count);
 644         size_t plen = 27 + segment_count + data_count;
 645         //Fix the CRC.
 646         write32ule(buffer + 22, ogg_crc32(ogg_crc32(0, NULL, 0), reinterpret_cast<uint8_t*>(buffer), plen));
 647 }
 648
 649 const uint64_t ogg_page::granulepos_none = 0xFFFFFFFFFFFFFFFFULL;
 650
 651
 652
 653 ogg_stream_reader::ogg_stream_reader() throw()
 654 {
 655         eof = false;
 656         left = 0;
 657         errors_to = &std::cerr;
 658         last_offset = 0;
 659         start_offset = 0;
 660 }
 661
 662 ogg_stream_reader::~ogg_stream_reader() throw()
 663 {
 664 }
 665
 666 void ogg_stream_reader::set_errors_to(std::ostream& os)
 667 {
 668         errors_to = &os;
 669 }
 670
 671 bool ogg_stream_reader::get_page(ogg_page& page) throw(std::exception)
 672 {
 673         size_t advance;
 674         bool f;
 675 try_again:
 676         fill_buffer();
 677         if(eof && !left)
 678                 return false;
 679         f = ogg_page::scan(buffer, left, eof, advance);
 680         if(advance) {
 681                 //The ogg stream resyncs.
 682                 (*errors_to) << "Warning: Ogg stream: Recapture after " << advance << " bytes." << std::endl;
 683                 discard_buffer(advance);
 684                 goto try_again;
 685         }
 686         if(!f)
 687                 goto try_again;
 688         page = ogg_page(buffer, advance);
 689         last_offset = start_offset;
 690         discard_buffer(advance);
 691         return true;
 692 }
 693
 694 void ogg_stream_reader::fill_buffer()
 695 {
 696         size_t r;
 697         if(!eof && left < sizeof(buffer)) {
 698                 left += (r = read(buffer + left, sizeof(buffer) - left));
 699                 if(!r)
 700                         eof = true;
 701         }
 702 }
 703
 704 void ogg_stream_reader::discard_buffer(size_t amount)
 705 {
 706         if(amount < left)
 707                 memmove(buffer, buffer + amount, left - amount);
 708         left -= amount;
 709         start_offset += amount;
 710 }
 711
 712 ogg_stream_writer::ogg_stream_writer() throw()
 713 {
 714 }
 715
 716 ogg_stream_writer::~ogg_stream_writer() throw()
 717 {
 718 }
 719
 720 void ogg_stream_writer::put_page(const ogg_page& page) throw(std::exception)
 721 {
 722         char buffer[65536];
 723         size_t s = page.serialize_size();
 724         page.serialize(buffer);
 725         write(buffer, s);
 726 }
 727
 728 ogg_stream_reader_iostreams::ogg_stream_reader_iostreams(std::istream& stream)
 729         : is(stream)
 730 {
 731 }
 732
 733 ogg_stream_reader_iostreams::~ogg_stream_reader_iostreams() throw()
 734 {
 735 }
 736
 737 size_t ogg_stream_reader_iostreams::read(char* buffer, size_t size) throw(std::exception)
 738 {
 739         if(!is)
 740                 return 0;
 741         is.read(buffer, size);
 742         return is.gcount();
 743 }
 744
 745 ogg_stream_writer_iostreams::ogg_stream_writer_iostreams(std::ostream& stream)
 746         : os(stream)
 747 {
 748 }
 749
 750 ogg_stream_writer_iostreams::~ogg_stream_writer_iostreams() throw()
 751 {
 752 }
 753
 754 void ogg_stream_writer_iostreams::write(const char* buffer, size_t size) throw(std::exception)
 755 {
 756         if(!os)
 757                 throw std::runtime_error("Error writing data");
 758         os.write(buffer, size);
 759         if(!os)
 760                 throw std::runtime_error("Error writing data");
 761 }