M4AFileSampleSizeBuffer.h

#pragma once
 
#include "AudioTools/CoreAudio/AudioPlayer.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "M4AAudioFileDemuxer.h"
 
namespace audio_tools {
 
class M4AFileSampleSizeBuffer : public BaseBuffer<stsz_sample_size_t> {
 public:
  M4AFileSampleSizeBuffer(AudioPlayer& player, ContainerM4A& container,
                          const char* fileExt = ".m4a") {
    this->p_player = &player;
    this->p_container = &container;
    player.setReference(this);
    player.setOnStreamChangeCallback(onFileChange);
    addFileExtension(fileExt);
  }
  M4AFileSampleSizeBuffer(AudioPlayer& player, ContainerM4A& container, {…}
 
  bool read(stsz_sample_size_t& data) override {
    if (p_file != nullptr && demuxer.getMdatOffset() == 0) {
      uint32_t offset = p_container->getDemuxer().getStszFileOffset();
      uint32_t s_count = p_container->getDemuxer().getSampleCount();
      demuxer.beginSampleSizeAccess(p_file, s_count, offset);
    }
    size_t pos = p_file->position();
    data = demuxer.getNextSampleSize();
    p_file->seek(pos);  // reset position after reading
    return demuxer;
  }
  bool read(stsz_sample_size_t& data) override  {…}
 
  void setReadBufferSize(size_t size) { demuxer.setSamplesBufferSize(size); }
 
  void addFileExtension(const char* fileExt) {
    fileExtensions.push_back(fileExt);
  }
  void addFileExtension(const char* fileExt) {…}
 
  void reset() {}
 
  bool write(stsz_sample_size_t data) { return true; }
 
  bool peek(stsz_sample_size_t& result) { return false; }
 
  int available() { return demuxer.sampleIndex(); };
 
  int availableForWrite() override { return 0; }  
 
  size_t size() override { return demuxer.size(); }
 
  stsz_sample_size_t* address() override { return nullptr; }
 
 protected:
  AudioPlayer* p_player = nullptr;     
  File* p_file = nullptr;              
  M4AAudioFileDemuxer demuxer;         
  Vector<const char*> fileExtensions;  
  ContainerM4A* p_container = nullptr;
 
  bool isRelevantFile(const char* name) {
    for (const auto& ext : fileExtensions) {
      if (StrView(name).endsWith(name)) return true;
    }
    return false;
  }
  bool isRelevantFile(const char* name) {…}
 
  static void onFileChange(Stream* streamPtr, void* reference) {
    M4AFileSampleSizeBuffer& self =
        *static_cast<M4AFileSampleSizeBuffer*>(reference);
    self.p_file = (File*)streamPtr;
    LOGI("===> M4AFileSampleSizeBuffer onFileChange: %s",
         self.p_file ? self.p_file->name() : "nullptr");
  }
  static void onFileChange(Stream* streamPtr, void* reference) {…}
};
class M4AFileSampleSizeBuffer : public BaseBuffer<stsz_sample_size_t> {…};
 
}  // namespace audio_tools