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