oggiterator.h

Go to the documentation of this file.

#ifndef TAG_PARSER_OGGITERATOR_H
#define TAG_PARSER_OGGITERATOR_H
 
#include "./oggpage.h"
 
#include <iosfwd>
#include <vector>
 
namespace TagParser {
 
class TAG_PARSER_EXPORT OggIterator {
public:
    OggIterator(std::istream &stream, std::uint64_t startOffset, std::uint64_t streamSize);
 
    void clear(std::istream &stream, std::uint64_t startOffset, std::uint64_t streamSize);
    std::istream &stream();
    void setStream(std::istream &stream);
    std::uint64_t startOffset() const;
    std::uint64_t streamSize() const;
    void reset();
    void nextPage();
    void nextSegment();
    void previousPage();
    void previousSegment();
    const std::vector<OggPage> &pages() const;
    std::vector<OggPage> &pages();
    const OggPage &currentPage() const;
    std::uint64_t currentPageOffset() const;
    std::vector<OggPage>::size_type currentPageIndex() const;
    void setPageIndex(std::vector<OggPage>::size_type index);
    void setSegmentIndex(std::vector<std::uint32_t>::size_type index);
    std::vector<std::uint32_t>::size_type currentSegmentIndex() const;
    std::uint64_t currentSegmentOffset() const;
    std::uint64_t currentCharacterOffset() const;
    std::uint64_t tellg() const;
    std::uint32_t currentSegmentSize() const;
    std::uint64_t remainingBytesInCurrentSegment() const;
    std::uint64_t bytesReadFromCurrentSegment() const;
    void setFilter(std::uint32_t streamSerialId);
    void removeFilter();
    bool isLastPageFetched() const;
    void read(char *buffer, std::size_t count);
    std::size_t readAll(char *buffer, std::size_t max);
    void ignore(std::size_t count = 1);
    bool bytesRemaining(std::size_t atLeast) const;
    bool resyncAt(std::uint64_t offset);
 
    operator bool() const;
    OggIterator &operator++();
    OggIterator operator++(int);
    OggIterator &operator--();
    OggIterator operator--(int);
 
private:
    bool fetchNextPage();
    bool matchesFilter(const OggPage &page);
 
    std::istream *m_stream;
    std::uint64_t m_startOffset;
    std::uint64_t m_streamSize;
    std::vector<OggPage> m_pages;
    std::vector<OggPage>::size_type m_page;
    std::vector<std::uint32_t>::size_type m_segment;
    std::uint64_t m_offset;
    std::uint64_t m_bytesRead;
    bool m_hasIdFilter;
    std::uint32_t m_idFilter;
};
 
inline OggIterator::OggIterator(std::istream &stream, std::uint64_t startOffset, std::uint64_t streamSize)
    : m_stream(&stream)
    , m_startOffset(startOffset)
    , m_streamSize(streamSize)
    , m_page(0)
    , m_segment(0)
    , m_offset(0)
    , m_bytesRead(0)
    , m_hasIdFilter(false)
    , m_idFilter(0)
{
}
 
inline std::istream &OggIterator::stream()
{
    return *m_stream;
}
 
inline void OggIterator::setStream(std::istream &stream)
{
    m_stream = &stream;
}
 
inline std::uint64_t OggIterator::startOffset() const
{
    return m_startOffset;
}
 
inline std::uint64_t OggIterator::streamSize() const
{
    return m_streamSize;
}
 
inline const std::vector<OggPage> &OggIterator::pages() const
{
    return m_pages;
}
 
inline std::vector<OggPage> &OggIterator::pages()
{
    return m_pages;
}
 
inline const OggPage &OggIterator::currentPage() const
{
    return m_pages[m_page];
}
 
inline std::uint64_t OggIterator::currentPageOffset() const
{
    return m_pages[m_page].startOffset();
}
 
inline OggIterator::operator bool() const
{
    return m_page < m_pages.size() && m_segment < m_pages[m_page].segmentSizes().size();
}
 
inline std::vector<OggPage>::size_type OggIterator::currentPageIndex() const
{
    return m_page;
}
 
inline void OggIterator::setPageIndex(std::vector<OggPage>::size_type index)
{
    const OggPage &page = m_pages[m_page = index];
    m_segment = 0;
    m_offset = page.startOffset() + page.headerSize();
}
 
inline void OggIterator::setSegmentIndex(std::vector<std::uint32_t>::size_type index)
{
    const OggPage &page = m_pages[m_page];
    m_offset = page.dataOffset(m_segment = index);
}
 
inline std::vector<std::uint32_t>::size_type OggIterator::currentSegmentIndex() const
{
    return m_segment;
}
 
inline std::uint64_t OggIterator::currentSegmentOffset() const
{
    return m_offset;
}
 
inline std::uint64_t OggIterator::currentCharacterOffset() const
{
    return m_offset + m_bytesRead;
}
 
inline std::uint64_t OggIterator::tellg() const
{
    return currentCharacterOffset();
}
 
inline std::uint32_t OggIterator::currentSegmentSize() const
{
    return m_pages[m_page].segmentSizes()[m_segment];
}
 
inline std::uint64_t OggIterator::remainingBytesInCurrentSegment() const
{
    return currentSegmentSize() - m_bytesRead;
}
 
inline uint64_t OggIterator::bytesReadFromCurrentSegment() const
{
    return m_bytesRead;
}
 
inline void OggIterator::setFilter(std::uint32_t streamSerialId)
{
    m_hasIdFilter = true;
    m_idFilter = streamSerialId;
}
 
inline void OggIterator::removeFilter()
{
    m_hasIdFilter = false;
}
 
inline bool OggIterator::isLastPageFetched() const
{
    return (m_pages.empty() ? m_startOffset : m_pages.back().startOffset() + m_pages.back().totalSize()) >= m_streamSize;
}
 
inline bool OggIterator::bytesRemaining(size_t atLeast) const
{
    return *this && currentCharacterOffset() + atLeast <= streamSize();
}
 
inline OggIterator &OggIterator::operator++()
{
    nextSegment();
    return *this;
}
 
inline OggIterator OggIterator::operator++(int)
{
    OggIterator tmp = *this;
    nextSegment();
    return tmp;
}
 
inline OggIterator &OggIterator::operator--()
{
    previousSegment();
    return *this;
}
 
inline OggIterator OggIterator::operator--(int)
{
    OggIterator tmp = *this;
    previousSegment();
    return tmp;
}
 
inline bool OggIterator::matchesFilter(const OggPage &page)
{
    return !m_hasIdFilter || m_idFilter == page.streamSerialNumber();
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_OGGITERATOR_H