SampleTableStore.h

Go to the documentation of this file.

#pragma once
#include <type_traits>
#include <utility>
 
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/CoreAudio/AudioLogger.h"
 
namespace audio_tools {
 
namespace quickstart_detail {
template <typename T>
class HasQuickStart {
  template <typename U>
  static auto test(int)
      -> decltype(std::declval<U&>().quickStart(), std::true_type());
  template <typename U>
  static std::false_type test(...);
 
 public:
  static const bool value = decltype(test<T>(0))::value;
};
 
template <typename T>
typename std::enable_if<HasQuickStart<T>::value, bool>::type
callQuickStartIfAvailable(T& writer) {
  return writer.quickStart();
}
 
template <typename T>
typename std::enable_if<!HasQuickStart<T>::value, bool>::type
callQuickStartIfAvailable(T&) {
  return false;
}
}  // namespace quickstart_detail
 
enum class TrackKind { Unknown, Audio, Video };
 
template <typename T>
class SampleTableStore {
 public:
  virtual ~SampleTableStore() = default;
  virtual void clear() = 0;
  virtual void append(T value) = 0;
  virtual size_t size() = 0;
  virtual T get(size_t index) = 0;
  virtual void setNextEntryOffset(uint64_t fileOffset) {}
  virtual void setOnDiskEntrySize(size_t bytes) {}
};
 
template <typename T>
class RamSampleTableStore : public SampleTableStore<T> {
 public:
  void clear() override { data.clear(); }
  void append(T value) override { data.push_back(value); }
  size_t size() override { return (size_t)data.size(); }
  T get(size_t index) override { return data[(int)index]; }
 
 protected:
  Vector<T> data;
};
 
template <typename T, size_t ChunkSize = 4096>
class ChunkedSampleTableStore : public SampleTableStore<T> {
 public:
  ~ChunkedSampleTableStore() { clear(); }
 
  void clear() override {
    for (size_t i = 0; i < chunks.size(); i++) delete[] chunks[i];
    chunks.clear();
    count = 0;
  }
 
  void append(T value) override {
    size_t chunk_idx = count / ChunkSize;
    size_t local_pos = count % ChunkSize;
    if (chunk_idx >= (size_t)chunks.size()) chunks.push_back(new T[ChunkSize]);
    chunks[(int)chunk_idx][local_pos] = value;
    count++;
  }
 
  size_t size() override { return count; }
 
  T get(size_t index) override {
    return chunks[(int)(index / ChunkSize)][index % ChunkSize];
  }
 
 protected:
  Vector<T*> chunks;  // small - one pointer per ChunkSize entries, not one per entry
  size_t count = 0;
};
 
class SeekableSource {
 public:
  virtual ~SeekableSource() = default;
  virtual bool seek(size_t pos) = 0;
  virtual size_t readBytes(uint8_t* data, size_t len) = 0;
};
 
template <typename FileT, typename WriterT>
class FileSeekableSource : public SeekableSource {
 public:
  FileSeekableSource(FileT& file, WriterT& writer, int bufferSize = 1024,
                     bool quickStart = true)
      : p_file(&file),
        p_writer(&writer),
        buffer_len(bufferSize),
        quick_start_enabled(quickStart) {
    writer.setSeekSource(*this);
  }
 
  bool seek(size_t pos) override {
    saved_pos = p_file->position();
    bool ok = p_file->seek(pos);
    if (debug_trace)
      LOGI("FileSeekableSource: seek(%u) saved_pos=%u post-seek position()=%u ok=%d",
           (unsigned)pos, (unsigned)saved_pos, (unsigned)p_file->position(), (int)ok);
    return ok;
  }
 
  size_t readBytes(uint8_t* data, size_t len) override {
    // File::readBytes() on some platforms (incl. this project's desktop
    // emulator) takes char*, not uint8_t* - readBytes(uint8_t*,size_t) is
    // the more common Arduino Stream signature, but not universal.
    size_t pre_pos = p_file->position();
    size_t n = p_file->readBytes((char*)data, len);
    if (debug_trace)
      LOGI("FileSeekableSource: readBytes len=%u pre_pos=%u got=%u restoring to saved_pos=%u",
           (unsigned)len, (unsigned)pre_pos, (unsigned)n, (unsigned)saved_pos);
    p_file->seek(saved_pos);  // restore the sequential-read position
    return n;
  }
 
  bool debug_trace = false;
 
  size_t copy() {
    if (quick_start_enabled && !quick_start_done) {
      quick_start_done = true;
      quickstart_detail::callQuickStartIfAvailable(*p_writer);
    }
    uint8_t buffer[buffer_len];
    size_t to_read = p_file->readBytes((char*)buffer, buffer_len);
    if (to_read == 0) return 0;
    size_t written = 0;
    int attempts = 0;
    while (written < to_read) {
      size_t w = p_writer->write(buffer + written, to_read - written);
      attempts++;
      if (w == 0) {
        LOGW("FileSeekableSource::copy(): writer stalled after accepting %u of %u "
             "bytes (%d attempt(s)) - dropping the remaining %u bytes",
             (unsigned)written, (unsigned)to_read, attempts, (unsigned)(to_read - written));
        break;
      }
      written += w;
    }
    if (debug_trace && attempts > 1)
      LOGI("FileSeekableSource::copy() needed %d attempts for to_read=%u", attempts, (unsigned)to_read);
    return written;
  }
 
 protected:
  FileT* p_file;
  WriterT* p_writer;
  int buffer_len;
  size_t saved_pos = 0;
  bool quick_start_enabled;
  bool quick_start_done = false;
};
 
template <typename T>
class SourceSeekSampleTableStore : public SampleTableStore<T> {
 public:
  static constexpr size_t kMaxOnDiskSize = 16;
 
  SourceSeekSampleTableStore(SeekableSource& source, size_t onDiskSize,
                              T (*decoder)(const uint8_t*),
                              size_t cacheEntries = 64)
      : p_source(&source),
        on_disk_size(onDiskSize),
        decode(decoder),
        cache_capacity(cacheEntries),
        cache(new T[cacheEntries]),
        raw_buf(new uint8_t[cacheEntries * kMaxOnDiskSize]) {}
 
  ~SourceSeekSampleTableStore() {
    delete[] cache;
    delete[] raw_buf;
  }
 
  void clear() override {
    count = 0;
    start_offset = -1;
    cache_len = 0;
  }
 
  void setNextEntryOffset(uint64_t fileOffset) override {
    if (start_offset < 0) start_offset = (int64_t)fileOffset;
  }
 
  void setOnDiskEntrySize(size_t bytes) override {
    on_disk_size = bytes;
    cache_len = 0;  // invalidate: any cached block used the old width
  }
 
  void append(T) override {
    // value itself is intentionally discarded - only its position matters
    count++;
  }
 
  size_t size() override { return count; }
 
  T get(size_t index) override {
    if (start_offset < 0 || p_source == nullptr) return T{};
    if (index < cache_start || index >= cache_start + cache_len)
      refillCache(index);
    if (index >= cache_start && index < cache_start + cache_len)
      return cache[index - cache_start];
    return T{};
  }
 
 protected:
  void refillCache(size_t index) {
    p_source->seek((size_t)(start_offset + (int64_t)(index * on_disk_size)));
    size_t got = p_source->readBytes(raw_buf, cache_capacity * on_disk_size);
    size_t got_entries = got / on_disk_size;
    for (size_t i = 0; i < got_entries; i++)
      cache[i] = decode(raw_buf + i * on_disk_size);
    cache_start = index;
    cache_len = got_entries;
  }
 
  SeekableSource* p_source;
  size_t on_disk_size;
  T (*decode)(const uint8_t*);
  int64_t start_offset = -1;
  size_t count = 0;
 
  size_t cache_capacity;
  T* cache;
  uint8_t* raw_buf;
  size_t cache_start = 0;
  size_t cache_len = 0;
};
 
class SpoolStorage : public SeekableSource {
 public:
  virtual size_t write(const uint8_t* data, size_t len) = 0;
};
 
template <typename FileT>
class FileSpoolStorage : public SpoolStorage {
 public:
  FileSpoolStorage(FileT& file) : p_file(&file) {}
  bool seek(size_t pos) override { return p_file->seek(pos); }
  size_t readBytes(uint8_t* data, size_t len) override {
    // see the identical comment in FileSeekableSource::readBytes()
    return p_file->readBytes((char*)data, len);
  }
  size_t write(const uint8_t* data, size_t len) override {
    return p_file->write(data, len);
  }
 
 protected:
  FileT* p_file;
};
 
template <typename T>
class SpoolFileSampleTableStore : public SampleTableStore<T> {
 public:
  SpoolFileSampleTableStore(SpoolStorage& spool) : p_spool(&spool) {}
 
  void clear() override {
    entry_count = 0;
    if (p_spool != nullptr) p_spool->seek(0);
  }
 
  void append(T value) override {
    if (p_spool == nullptr) return;
    p_spool->seek(entry_count * sizeof(T));
    p_spool->write((const uint8_t*)&value, sizeof(T));
    entry_count++;
  }
 
  size_t size() override { return entry_count; }
 
  T get(size_t index) override {
    T value{};
    if (p_spool == nullptr) return value;
    p_spool->seek(index * sizeof(T));
    p_spool->readBytes((uint8_t*)&value, sizeof(T));
    return value;
  }
 
 protected:
  SpoolStorage* p_spool;
  size_t entry_count = 0;
};
 
enum class SampleTableKind { SampleSizes, ChunkOffsets, Stsc, Stts };
 
class SpoolStorageFactory {
 public:
  virtual ~SpoolStorageFactory() = default;
  virtual SpoolStorage* createSpoolStorage(TrackKind trackKind,
                                            SampleTableKind tableKind) = 0;
};
 
}  // namespace audio_tools