src/library/ogg.cpp

   1 #include "ogg.hpp"
   2 #include "serialization.hpp"
   3 #include "minmax.hpp"
   4 #include "hex.hpp"
   5 #include <cstring>
   6 #include <zlib.h>
   7 #include <algorithm>
   8 #include <iostream>
   9 #include <iomanip>
  10 #include "string.hpp"
  11
  12 namespace ogg
  13 {
  14 namespace {
  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
  80         };
  81
  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)
  84         {
  85                 if(!data)
  86                         return 0;
  87                 for(size_t i = 0; i < size; i++)
  88                         chain = (chain << 8) ^ crc_lookup[(chain >> 24) ^ data[i]];
  89                 return chain;
  90         }
  91 }
  92
  93
  94 packet::packet(uint64_t granule, bool first, bool last, bool spans, bool eos, bool bos,
  95         const std::vector<uint8_t>& d)
  96 {
  97         data = d;
  98         granulepos = granule;
  99         first_page = first;
 100         last_page = last;
 101         spans_page = spans;
 102         eos_page = eos;
 103         bos_page = bos;
 104 }
 105
 106 demuxer::demuxer(std::ostream& _errors_to)
 107         : errors_to(_errors_to)
 108 {
 109         seen_page = false;
 110         imprint_stream = 0;
 111         page_seq = 0;
 112         page_era = 0;
 113         dpacket = 0;
 114         packets = 0;
 115         ended = false;
 116         damaged_packet = false;
 117         last_granulepos = 0;
 118 }
 119
 120 uint64_t demuxer::page_fullseq(uint32_t seq)
 121 {
 122         if(seq < page_seq)
 123                 return (static_cast<uint64_t>(page_era + 1) << 32) + seq;
 124         else
 125                 return (static_cast<uint64_t>(page_era) << 32) + seq;
 126 }
 127
 128 void demuxer::update_pageseq(uint32_t new_seq)
 129 {
 130         if(new_seq < page_seq)
 131                 page_era++;
 132         page_seq = new_seq;
 133 }
 134
 135 bool demuxer::complain_lost_page(uint32_t new_seq, uint32_t stream)
 136 {
 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;
 144                 else
 145                         errors_to << "Warning: Ogg demux: Pages " << first_missing << "-" << last_missing
 146                                 << " missing on stream " << hex::to(stream) << std::endl;
 147                 return true;
 148         }
 149         return false;
 150 }
 151
 152 void demuxer::complain_continue_errors(unsigned flags, uint32_t seqno, uint32_t stream, uint32_t pkts,
 153         uint64_t granule)
 154 {
 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);
 162         if(!continued) {
 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;
 168         } else {
 169                 if(bos)
 170                         errors_to << "Warning: Ogg demux: BOS page has CONTINUED set (stream " << stream << ")."
 171                                 << std::endl;
 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;
 179         }
 180         if(incomplete && eos)
 181                 errors_to << "Warning: Ogg demux: EOS page with incomplete packet (stream " << stream << ")."
 182                         << std::endl;
 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;
 189 }
 190
 191 bool demuxer::page_in(const page& p)
 192 {
 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.
 197         if(!wants_page_in())
 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;
 212         if(seen_page && bos)
 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.
 217         unsigned flags = 0;
 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);
 226         if(continued) {
 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;
 235                         seen_page = true;
 236                         imprint_stream = stream;
 237                         update_pageseq(sequence);
 238                         ended = eos;
 239                         if(granulepos != page::granulepos_none)
 240                                 last_granulepos = granulepos;
 241                         return true;
 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);
 248                         seen_page = true;
 249                         imprint_stream = stream;
 250                         update_pageseq(sequence);
 251                         damaged_packet = false;
 252                         ended = eos;
 253                         dpacket = 1;
 254                         packets = 1;
 255                         if(granulepos != page::granulepos_none)
 256                                 last_granulepos = granulepos;
 257                         return true;
 258                 }
 259         }
 260         dpacket = (continued && (partial.empty() || damaged_packet || gap)) ? 1 : 0;    //Busted?
 261         packets = pkts;
 262         if(incomplete)
 263                 packets--;
 264         last_page = p;
 265         damaged_packet = false;
 266         seen_page = true;
 267         imprint_stream = stream;
 268         update_pageseq(sequence);
 269         ended = eos;
 270         if(granulepos != page::granulepos_none)
 271                 last_granulepos = granulepos;
 272         return true;
 273 }
 274
 275 void demuxer::packet_out(ogg::packet& pkt)
 276 {
 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());
 281         if(!firstfrag) {
 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);
 289         } else {
 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);
 298         }
 299         if(lastfrag) {
 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();
 307         }
 308         dpacket++;
 309 }
 310
 311 void demuxer::discard_packet()
 312 {
 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());
 316         if(lastfrag) {
 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);
 323         }
 324         dpacket++;
 325 }
 326
 327 muxer::muxer(uint32_t streamid, uint64_t _seq)
 328 {
 329         strmid = streamid;
 330         written = 0;
 331         eos_asserted = false;
 332         seq = _seq;
 333         granulepos = page::granulepos_none;
 334         buffer.set_granulepos(page::granulepos_none);
 335 }
 336
 337
 338 bool muxer::packet_fits(size_t pktsize) const throw()
 339 {
 340         return pktsize <= buffer.get_max_complete_packet();
 341 }
 342
 343 bool muxer::wants_packet_in() const throw()
 344 {
 345         return buffered.size() == written && !eos_asserted;
 346 }
 347
 348 bool muxer::has_page_out() const throw()
 349 {
 350         return buffer.get_packet_count() > 0;
 351 }
 352
 353 void muxer::signal_eos()
 354 {
 355         eos_asserted = true;
 356 }
 357
 358 void muxer::packet_in(const std::vector<uint8_t>& data, uint64_t granule)
 359 {
 360         if(!wants_packet_in() || eos_asserted)
 361                 throw std::runtime_error("Muxer not ready for packet");
 362         buffered = data;
 363         //Try direct write.
 364         const uint8_t* _data = &data[0];
 365         size_t _len = data.size();
 366         bool r = buffer.append_packet_incomplete(_data, _len);
 367         if(r) {
 368                 written = data.size();
 369                 buffer.set_granulepos(granule);
 370                 return;         //Complete write.
 371         }
 372         granulepos = granule;
 373         written = data.size() - _len;
 374 }
 375
 376 void muxer::page_out(page& p)
 377 {
 378         if(!has_page_out())
 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);
 385         p = buffer;
 386         buffer = page();
 387         seq++;
 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);
 393                 if(r) {
 394                         written = buffered.size();
 395                         buffer.set_granulepos(granulepos);
 396                         buffer.set_continue(written != 0);
 397                         granulepos = page::granulepos_none;
 398                         return;
 399                 }
 400                 written = buffered.size() - _len;
 401         }
 402         buffer.set_granulepos(page::granulepos_none);
 403 }
 404
 405 page::page() throw()
 406 {
 407         version = 0;
 408         flag_continue = false;
 409         flag_bos = false;
 410         flag_eos = false;
 411         last_incomplete = false;
 412         granulepos = granulepos_none;
 413         stream = 0;
 414         sequence = 0;
 415         segment_count = 0;
 416         packet_count = 0;
 417         data_count = 0;
 418         memset(data, 0, sizeof(data));
 419         memset(segments, 0, sizeof(segments));
 420         memset(packets, 0, sizeof(packets));
 421 }
 422
 423 page::page(const char* buffer, size_t& advance) throw(std::runtime_error)
 424 {
 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");
 428         if(buffer[4] != 0)
 429                 throw std::runtime_error("Bad Ogg page version");
 430         if(buffer[5] & 0xF8)
 431                 throw std::runtime_error("Bad Ogg page flags");
 432         //Compute length.
 433         size_t b = 27 + (unsigned char)buffer[26];
 434         data_count = 0;
 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];
 438         }
 439         //Check the CRC.
 440         uint32_t claimed = serialization::u32l(buffer + 22);
 441         uint32_t x = 0;
 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.
 449         version = buffer[4];
 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));
 459         if(segment_count)
 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);
 464         packet_count = 0;
 465         memset(packets, 0, sizeof(packets));
 466         if(segment_count > 0)
 467                 packets[packet_count++] = 0;
 468         uint16_t dptr = 0;
 469         for(unsigned i = 0; i < segment_count; i++) {
 470                 dptr += segments[i];
 471                 if(segment_count > i + 1 && segments[i] < 255)
 472                         packets[packet_count++] = dptr;
 473         }
 474         packets[packet_count] = dptr;
 475         last_incomplete = (!flag_eos && segment_count > 0 && segments[segment_count - 1] == 255);
 476         advance = b;
 477 }
 478
 479 bool page::scan(const char* buffer, size_t bufferlen, bool eof, size_t& advance) throw()
 480 {
 481         const char* _buffer = buffer;
 482         size_t buffer_left = bufferlen;
 483         advance = 0;
 484         while(buffer_left >= 27) {
 485                 //Check capture pattern.
 486                 if(_buffer[0] != 'O' || _buffer[1] != 'g' || _buffer[2] != 'g' || _buffer[3] != 'S') {
 487                         advance++;
 488                         _buffer++;
 489                         buffer_left--;
 490                         continue;
 491                 }
 492                 //Check that version is valid.
 493                 if(_buffer[4] != 0) {
 494                         advance++;
 495                         _buffer++;
 496                         buffer_left--;
 497                         continue;
 498                 }
 499                 //Check that flags are valid.
 500                 if(_buffer[5] & 0xF8) {
 501                         advance++;
 502                         _buffer++;
 503                         buffer_left--;
 504                         continue;
 505                 }
 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) {
 508                         if(!eof) {
 509                                 return false;
 510                         } else {
 511                                 advance++;
 512                                 _buffer++;
 513                                 buffer_left--;
 514                                 continue;
 515                         }
 516                 }
 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) {
 522                         if(!eof) {
 523                                 return false;
 524                         } else {
 525                                 advance++;
 526                                 _buffer++;
 527                                 buffer_left--;
 528                                 continue;
 529                         }
 530                 }
 531                 //Check the CRC.
 532                 uint32_t claimed = serialization::u32l(_buffer + 22);
 533                 uint32_t x = 0;
 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.
 540                         advance++;
 541                         _buffer++;
 542                         buffer_left--;
 543                         continue;
 544                 }
 545                 return true;    //Here is a packet.
 546         }
 547         if(eof && buffer_left < 27) {
 548                 //Advance to the end.
 549                 advance += buffer_left;
 550         }
 551         return false;
 552 }
 553
 554 std::string page::stream_debug_id() const throw(std::bad_alloc)
 555 {
 556         return (stringfmt() << "Stream " << hex::to(stream)).str();
 557 }
 558
 559 std::string page::page_debug_id() const throw(std::bad_alloc)
 560 {
 561         return (stringfmt() << stream_debug_id() << " page " << sequence).str();
 562 }
 563
 564 size_t page::get_max_complete_packet() const throw()
 565 {
 566         if(segment_count == 255)
 567                 return 0;
 568         return (255 - segment_count) * 255 - 1;
 569 }
 570
 571 bool page::append_packet(const uint8_t* _data, size_t datalen) throw()
 572 {
 573         //Compute the smallest amount of data we can't write.
 574         size_t imin = (255 - segment_count) * 255;
 575         if(datalen >= imin)
 576                 return false;           //Can't write.
 577         //Okay, it fits. Write.
 578         packets[packet_count++] = data_count;
 579         bool terminate = false;
 580         while(datalen > 0) {
 581                 if(datalen >= 255) {
 582                         segments[segment_count++] = 255;
 583                         memcpy(data + data_count, _data, 255);
 584                         data_count += 255;
 585                         _data += 255;
 586                         datalen -= 255;
 587                 } else {
 588                         segments[segment_count++] = datalen;
 589                         memcpy(data + data_count, _data, datalen);
 590                         data_count += datalen;
 591                         _data += datalen;
 592                         datalen = 0;
 593                         terminate = true;
 594                 }
 595         }
 596         if(!terminate)
 597                 segments[segment_count++] = 0;
 598         packets[packet_count] = data_count;
 599         last_incomplete = false;
 600         return true;
 601 }
 602
 603 bool page::append_packet_incomplete(const uint8_t*& _data, size_t& datalen) throw()
 604 {
 605         //If we have absolutely no space, don't flag a packet.
 606         if(segment_count == 255)
 607                 return false;
 608         packets[packet_count++] = data_count;
 609         //Append segments, one by one.
 610         while(segment_count < 255) {
 611                 if(datalen >= 255) {
 612                         segments[segment_count++] = 255;
 613                         memcpy(data + data_count, _data, 255);
 614                         data_count += 255;
 615                         _data += 255;
 616                         datalen -= 255;
 617                 } else {
 618                         //Final segment of packet.
 619                         segments[segment_count++] = datalen;
 620                         memcpy(data + data_count, _data, datalen);
 621                         data_count += datalen;
 622                         _data += datalen;
 623                         datalen = 0;
 624                         packets[packet_count] = data_count;
 625                         last_incomplete = false;
 626                         return true;
 627                 }
 628         }
 629         packets[packet_count] = data_count;
 630         last_incomplete = true;
 631         return false;
 632 }
 633
 634 void page::serialize(char* buffer) const throw()
 635 {
 636         memcpy(buffer, "OggS", 4);
 637         buffer[4] = version;
 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;
 647         //Fix the CRC.
 648         serialization::u32l(buffer + 22, oggcrc32(oggcrc32(0, NULL, 0), reinterpret_cast<uint8_t*>(buffer), plen));
 649 }
 650
 651 const uint64_t page::granulepos_none = 0xFFFFFFFFFFFFFFFFULL;
 652
 653
 654
 655 stream_reader::stream_reader() throw()
 656 {
 657         eof = false;
 658         left = 0;
 659         errors_to = &std::cerr;
 660         last_offset = 0;
 661         start_offset = 0;
 662 }
 663
 664 stream_reader::~stream_reader() throw()
 665 {
 666 }
 667
 668 void stream_reader::set_errors_to(std::ostream& os)
 669 {
 670         errors_to = &os;
 671 }
 672
 673 bool stream_reader::get_page(page& spage) throw(std::exception)
 674 {
 675         size_t advance;
 676         bool f;
 677 try_again:
 678         fill_buffer();
 679         if(eof && !left)
 680                 return false;
 681         f = page::scan(buffer, left, eof, advance);
 682         if(advance) {
 683                 //The ogg stream resyncs.
 684                 (*errors_to) << "Warning: Ogg stream: Recapture after " << advance << " bytes." << std::endl;
 685                 discard_buffer(advance);
 686                 goto try_again;
 687         }
 688         if(!f)
 689                 goto try_again;
 690         spage = page(buffer, advance);
 691         last_offset = start_offset;
 692         discard_buffer(advance);
 693         return true;
 694 }
 695
 696 void stream_reader::fill_buffer()
 697 {
 698         size_t r;
 699         if(!eof && left < sizeof(buffer)) {
 700                 left += (r = read(buffer + left, sizeof(buffer) - left));
 701                 if(!r)
 702                         eof = true;
 703         }
 704 }
 705
 706 void stream_reader::discard_buffer(size_t amount)
 707 {
 708         if(amount < left)
 709                 memmove(buffer, buffer + amount, left - amount);
 710         left -= amount;
 711         start_offset += amount;
 712 }
 713
 714 stream_writer::stream_writer() throw()
 715 {
 716 }
 717
 718 stream_writer::~stream_writer() throw()
 719 {
 720 }
 721
 722 void stream_writer::put_page(const page& page) throw(std::exception)
 723 {
 724         char buffer[65536];
 725         size_t s = page.serialize_size();
 726         page.serialize(buffer);
 727         write(buffer, s);
 728 }
 729
 730 stream_reader_iostreams::stream_reader_iostreams(std::istream& stream)
 731         : is(stream)
 732 {
 733 }
 734
 735 stream_reader_iostreams::~stream_reader_iostreams() throw()
 736 {
 737 }
 738
 739 size_t stream_reader_iostreams::read(char* buffer, size_t size) throw(std::exception)
 740 {
 741         if(!is)
 742                 return 0;
 743         is.read(buffer, size);
 744         return is.gcount();
 745 }
 746
 747 stream_writer_iostreams::stream_writer_iostreams(std::ostream& stream)
 748         : os(stream)
 749 {
 750 }
 751
 752 stream_writer_iostreams::~stream_writer_iostreams() throw()
 753 {
 754 }
 755
 756 void stream_writer_iostreams::write(const char* buffer, size_t size) throw(std::exception)
 757 {
 758         if(!os)
 759                 throw std::runtime_error("Error writing data");
 760         os.write(buffer, size);
 761         if(!os)
 762                 throw std::runtime_error("Error writing data");
 763 }
 764 }