include/library/ogg.hpp

   1 #ifndef _library__ogg__hpp__included__
   2 #define _library__ogg__hpp__included__
   3
   4 #include <cstdint>
   5 #include <stdexcept>
   6 #include <vector>
   7 #include <map>
   8
   9 namespace ogg
  10 {
  11 /**
  12  * A packet in Ogg bitstream.
  13  */
  14 class packet
  15 {
  16 public:
  17 /**
  18  * Constructor.
  19  */
  20         packet() {}
  21 /**
  22  * Constructor.
  23  */
  24         packet(uint64_t granule, bool first, bool last, bool spans, bool eos, bool bos,
  25                 const std::vector<uint8_t>& d);
  26 /**
  27  * Is the packet first within its page?
  28  */
  29         bool get_first_page() const throw() { return first_page; }
  30 /**
  31  * Is the packet last within its page?
  32  */
  33         bool get_last_page() const throw() { return last_page; }
  34 /**
  35  * Is the packet spanning multiple pages?
  36  */
  37         bool get_spans_page() const throw() { return spans_page; }
  38 /**
  39  * Is atomic (first, last and on one page)?
  40  */
  41         bool get_atomic() const throw() { return first_page && last_page && !spans_page; }
  42 /**
  43  * Get the granule position within page the packet finished at.
  44  */
  45         uint64_t get_granulepos() const throw() { return granulepos; }
  46 /**
  47  * Does the page this ends on have EOS set?
  48  */
  49         bool get_on_eos_page() const throw() { return eos_page; }
  50 /**
  51  * Does the page this starts on have BOS set?
  52  */
  53         bool get_on_bos_page() const throw() { return bos_page; }
  54 /**
  55  * Get the packet data.
  56  */
  57         const std::vector<uint8_t>& get_vector() const throw() { return data; }
  58 /**
  59  * Get length of packet data.
  60  */
  61         size_t get_length() const throw() { return data.size(); }
  62 /**
  63  * Get packet data.
  64  */
  65         const uint8_t* get_data() const throw() { return &data[0]; }
  66 private:
  67         bool first_page;
  68         bool last_page;
  69         bool spans_page;
  70         bool eos_page;
  71         bool bos_page;
  72         uint64_t granulepos;
  73         std::vector<uint8_t> data;
  74 };
  75
  76 /**
  77  * A page in Ogg bitstream.
  78  */
  79 class page
  80 {
  81 public:
  82 /**
  83  * Create a new blank page.
  84  */
  85         page() throw();
  86 /**
  87  * Create a page, reading a buffer.
  88  *
  89  * Parameter buffer: The buffer to read.
  90  * Parameter advance: The number of bytes in packet is stored here.
  91  * Throws std::runtime_error: Bad packet.
  92  */
  93         page(const char* buffer, size_t& advance);
  94 /**
  95  * Scan a buffer for pages.
  96  *
  97  * Parameter buffer: The buffer to scan.
  98  * Parameter bufferlen: The length of buffer. Should be at least 65307, unless there's not that much available.
  99  * Parameter eof: If set, assume physical stream ends after this buffer.
 100  * Parameter advance: Amount to advance the pointer is stored here.
 101  * Returns: True if packet was found, false if not.
 102  */
 103         static bool scan(const char* buffer, size_t bufferlen, bool eof, size_t& advance) throw();
 104 /**
 105  * Get the continue flag of packet.
 106  */
 107         bool get_continue() const throw() { return flag_continue; }
 108 /**
 109  * Set the continue flag of packet.
 110  */
 111         void set_continue(bool c) throw() { flag_continue = c; }
 112 /**
 113  * Get the BOS flag of packet.
 114  */
 115         bool get_bos() const throw() { return flag_bos; }
 116 /**
 117  * Set the BOS flag of packet.
 118  */
 119         void set_bos(bool b) throw() { flag_bos = b; }
 120 /**
 121  * Get the EOS flag of packet.
 122  */
 123         bool get_eos() const throw() { return flag_eos; }
 124 /**
 125  * Set the EOS flag of packet.
 126  */
 127         void set_eos(bool e) throw() { flag_eos = e; }
 128 /**
 129  * Get the granulepos of packet.
 130  */
 131         uint64_t get_granulepos() const throw() { return granulepos; }
 132 /**
 133  * Set the granulepos of packet.
 134  */
 135         void set_granulepos(uint64_t g) throw() { granulepos = g; }
 136 /**
 137  * Get stream identifier.
 138  */
 139         uint32_t get_stream() const throw() { return stream; }
 140 /**
 141  * Set stream identifier.
 142  */
 143         void set_stream(uint32_t s) throw() { stream = s; }
 144 /**
 145  * Get stream identifier.
 146  */
 147         uint32_t get_sequence() const throw() { return sequence; }
 148 /**
 149  * Set stream identifier.
 150  */
 151         void set_sequence(uint32_t s) throw() { sequence = s; }
 152 /**
 153  * Get number of packets.
 154  */
 155         uint8_t get_packet_count() const throw() { return packet_count; }
 156 /**
 157  * Get the packet.
 158  */
 159         std::pair<const uint8_t*, size_t> get_packet(size_t packetno) const throw()
 160         {
 161                 if(packetno >= packet_count)
 162                         return std::make_pair(reinterpret_cast<const uint8_t*>(NULL), 0);
 163                 else
 164                         return std::make_pair(data + packets[packetno], packets[packetno + 1] - packets[packetno]);
 165         }
 166 /**
 167  * Get the last packet incomplete flag.
 168  */
 169         bool get_last_packet_incomplete() const throw() { return last_incomplete; }
 170 /**
 171  * Get amount of data that can be written as a complete packet.
 172  */
 173         size_t get_max_complete_packet() const throw();
 174 /**
 175  * Append a complete packet to page.
 176  *
 177  * Parameter d: The data to append.
 178  * Parameter dlen: The length of data to append.
 179  * Returns: True on success, false on failure.
 180  */
 181         bool append_packet(const uint8_t* d, size_t dlen) throw();
 182 /**
 183  * Append a possibly incomplete packet to page.
 184  *
 185  * Parameter d: The data to append. Adjusted.
 186  * Parameter dlen: The length of data to append. Adjusted
 187  * Returns: True if write was complete, false if incomplete.
 188  */
 189         bool append_packet_incomplete(const uint8_t*& d, size_t& dlen) throw();
 190 /**
 191  * Get number of octets it takes to serialize this.
 192  */
 193         size_t serialize_size() const throw() { return 27 + segment_count + data_count; }
 194 /**
 195  * Serialize this packet.
 196  *
 197  * Parameter buffer: Buffer to serialize to (use serialize_size() to find the size).
 198  */
 199         void serialize(char* buffer) const throw();
 200 /**
 201  * Get debugging info for stream this page is from.
 202  */
 203         std::string stream_debug_id() const;
 204 /**
 205  * Get debugging info for this page.
 206  */
 207         std::string page_debug_id() const;
 208 /**
 209  * The special granule pos for nothing.
 210  */
 211         const static uint64_t granulepos_none;
 212 private:
 213         uint8_t version;
 214         bool flag_continue;
 215         bool flag_bos;
 216         bool flag_eos;
 217         bool last_incomplete;
 218         uint64_t granulepos;
 219         uint32_t stream;
 220         uint32_t sequence;
 221         uint8_t segment_count;
 222         uint8_t packet_count;
 223         uint16_t data_count;
 224         uint8_t data[65025];
 225         uint8_t segments[255];
 226         uint16_t packets[256];
 227 };
 228
 229 /**
 230  * Ogg demuxer.
 231  */
 232 class demuxer
 233 {
 234 public:
 235 /**
 236  * Create a new demuxer.
 237  */
 238         demuxer(std::ostream& _errors_to);
 239 /**
 240  * Demuxer wants a page in?
 241  */
 242         bool wants_page_in() const throw() { return (dpacket == packets && !ended); }
 243 /**
 244  * Demuxer wants a packet out?
 245  */
 246         bool wants_packet_out() const throw() { return (dpacket < packets); }
 247 /**
 248  * Input a page.
 249  */
 250         bool page_in(const page& p);
 251 /**
 252  * Output a packet.
 253  */
 254         void packet_out(packet& pkt);
 255 /**
 256  * Discard a packet.
 257  */
 258         void discard_packet();
 259 private:
 260         uint32_t inc1(uint32_t x) { return x + 1; }
 261         uint64_t page_fullseq(uint32_t seq);
 262         void update_pageseq(uint32_t new_seq);
 263         bool complain_lost_page(uint32_t new_seq, uint32_t stream);
 264         void complain_continue_errors(unsigned flags, uint32_t seqno, uint32_t stream, uint32_t pkts,
 265                 uint64_t granule);
 266         std::ostream& errors_to;
 267         std::vector<uint8_t> partial;
 268         bool started_bos;
 269         bool seen_page;
 270         bool damaged_packet;
 271         uint32_t imprint_stream;
 272         uint32_t page_seq;
 273         uint32_t page_era;
 274         page last_page;
 275         uint32_t dpacket;
 276         uint32_t packets;
 277         uint64_t last_granulepos;
 278         bool ended;
 279 };
 280
 281 /**
 282  * Ogg muxer.
 283  */
 284 class muxer
 285 {
 286 public:
 287 /**
 288  * Create a muxer.
 289  */
 290         muxer(uint32_t streamid, uint64_t _seq = 0);
 291 /**
 292  * Wants a packet?
 293  */
 294         bool wants_packet_in() const throw();
 295 /**
 296  * Packet of this size fits on current page?
 297  */
 298         bool packet_fits(size_t pktsize) const throw();
 299 /**
 300  * Has a page to output?
 301  */
 302         bool has_page_out() const throw();
 303 /**
 304  * Input a packet.
 305  */
 306         void packet_in(const std::vector<uint8_t>& data, uint64_t granule);
 307 /**
 308  * Signal end of stream.
 309  */
 310         void signal_eos();
 311 /**
 312  * Output a page.
 313  */
 314         void page_out(page& p);
 315 private:
 316         uint32_t strmid;
 317         page buffer;
 318         std::vector<uint8_t> buffered;
 319         size_t written;
 320         uint64_t seq;
 321         bool eos_asserted;
 322         uint64_t granulepos;
 323 };
 324
 325 /**
 326  * Ogg stream reader.
 327  */
 328 class stream_reader
 329 {
 330 public:
 331 /**
 332  * Constructor.
 333  */
 334         stream_reader() throw();
 335 /**
 336  * Destructor.
 337  */
 338         virtual ~stream_reader() throw();
 339 /**
 340  * Read some data.
 341  *
 342  * Parameter buffer: The buffer to store the data to.
 343  * Parameter size: The maximum size to read.
 344  * Returns: The number of bytes actually read.
 345  */
 346         virtual size_t read(char* buffer, size_t size) = 0;
 347 /**
 348  * Read a page from stream.
 349  *
 350  * Parameter page: The page is assigned here if successful.
 351  * Returns: True if page was obtained, false if not.
 352  */
 353         bool get_page(page& page);
 354 /**
 355  * Set stream to report errors to.
 356  *
 357  * Parameter strm: The stream.
 358  */
 359         void set_errors_to(std::ostream& os);
 360 /**
 361  * Starting offset of last packet returned.
 362  */
 363         uint64_t get_last_offset() { return last_offset; }
 364 private:
 365         stream_reader(const stream_reader&);
 366         stream_reader& operator=(const stream_reader&);
 367         void fill_buffer();
 368         void discard_buffer(size_t amount);
 369         bool eof;
 370         char buffer[65536];
 371         size_t left;
 372         uint64_t last_offset;
 373         uint64_t start_offset;
 374         std::ostream* errors_to;
 375 };
 376
 377 /**
 378  * Ogg stream reader based on std::istream.
 379  */
 380 class stream_reader_iostreams : public stream_reader
 381 {
 382 public:
 383 /**
 384  * Constructor.
 385  *
 386  * Parameter stream: The stream to read the data from.
 387  */
 388         stream_reader_iostreams(std::istream& stream);
 389 /**
 390  * Destructor.
 391  */
 392         ~stream_reader_iostreams() throw();
 393
 394         size_t read(char* buffer, size_t size);
 395 private:
 396         std::istream& is;
 397 };
 398
 399 /**
 400  * Ogg stream writer.
 401  */
 402 class stream_writer
 403 {
 404 public:
 405 /**
 406  * Constructor.
 407  */
 408         stream_writer() throw();
 409 /**
 410  * Destructor.
 411  */
 412         virtual ~stream_writer() throw();
 413 /**
 414  * Write data.
 415  *
 416  * Parameter data: The data to write.
 417  * Parameter size: The size to write.
 418  */
 419         virtual void write(const char* buffer, size_t size) = 0;
 420 /**
 421  * Write a page to stream.
 422  *
 423  * Parameter page: The page to write.
 424  */
 425         void put_page(const page& page);
 426 private:
 427         stream_writer(const stream_writer&);
 428         stream_writer& operator=(const stream_writer&);
 429 };
 430
 431 /**
 432  * Ogg stream writer based on std::istream.
 433  */
 434 class stream_writer_iostreams : public stream_writer
 435 {
 436 public:
 437 /**
 438  * Constructor.
 439  *
 440  * Parameter stream: The stream to read the data from.
 441  */
 442         stream_writer_iostreams(std::ostream& stream);
 443 /**
 444  * Destructor.
 445  */
 446         ~stream_writer_iostreams() throw();
 447
 448         void write(const char* buffer, size_t size);
 449 private:
 450         std::ostream& os;
 451 };
 452 }
 453
 454 #endif