take class

class Take {
public:
    // constructor
    Take(MediaItem* item) : item(item) { take = GetActiveTake(item); };
    Take(MediaItem_Take* take) : take(take) { item = GetMediaItemTake_Item(take); };

    // conversion
    operator MediaItem*() const { return item; }
    operator MediaItem_Take*() const { return take; }
    operator int() const { return GetMediaItemTakeInfo_Value(take, "IP_TAKENUMBER"); }
    operator string() const { return GetTakeName(take); }

    // operator
    const vector<double>& operator[](int i) { return m_audiobuf[i]; } //todo: error if audio is not loaded

private:
    // basic properties
    MediaItem_Take* take;
    MediaItem* item;

    // audio properties
    PCM_source* source = nullptr;
    int m_srate = 0;
    size_t m_frames = 0;
    int m_nch = 0;
    int m_bitdepth = 0;

    string m_audiofile_path;
    int m_audiofile_frames = 0;
    double m_audiofile_length = 0.0;

    vector<vector<double>> m_audiobuf;
    double m_audiobuf_starttime = -1;
    double m_audiobuf_endtime = -1;

public:
    // getters
    int idx() { return GetMediaItemTakeInfo_Value(take, "IP_TAKENUMBER"); }
    int chanmode() { return GetMediaItemTakeInfo_Value(take, "I_CHANMODE"); }
    double rate() { return GetMediaItemTakeInfo_Value(take, "D_PLAYRATE"); }
    double vol() { return GetMediaItemTakeInfo_Value(take, "D_VOL"); }
    double length() { return GetMediaItemInfo_Value(item, "D_LENGTH"); }

    string name() { return GetTakeName(take); }
    int samplerate() { if (!m_srate) InitAudio(); return m_srate; }
    int bitdepth() { if (!m_bitdepth) InitAudio(); return m_bitdepth; }
    size_t frames() { return m_frames; }
    int nch() { if (!m_nch) InitAudio(); return m_nch;}

    const vector<vector<double>>& audio() { return m_audiobuf; } //todo: error if audio is not loaded
    int audiofile_frames() { return m_audiofile_frames; }
    const string& audiofile_path() {  return m_audiofile_path; }

    // setters
    void name(const string& s) { GetSetMediaItemTakeInfo_String(take, "P_NAME", (char*)s.c_str(), 1); }
    void chanmode(int c) { SetMediaItemTakeInfo_Value(take, "I_CHANMODE", c); }

    // functions
public:
    void InitAudio();
    void LoadAudio(double starttime = -1, double endtime = -1);
};

void Take::InitAudio() {
    source = GetMediaItemTake_Source(take);

    m_audiofile_path = source->GetFileName();
    m_srate = source->GetSampleRate();
    m_audiofile_frames = length() * m_srate;
    m_audiofile_length = source->GetLength();
    m_bitdepth = source->GetBitsPerSample();
    m_nch = source->GetNumChannels();
}

void Take::LoadAudio(double starttime, double endtime) {
    if (!m_nch) InitAudio();

    if (starttime == -1) starttime = m_audiobuf_starttime = 0;
    if (endtime == -1) { endtime = m_audiobuf_endtime = length(); }

    int initial_chanmode = chanmode();
    chanmode(0);

    m_frames = (endtime - starttime) * (double)m_srate;
    vector<double> buffer(m_frames * m_nch, 0);
    AudioAccessor* accessor = CreateTakeAudioAccessor(take);
    GetAudioAccessorSamples(accessor, m_srate, m_nch, starttime, m_frames, buffer.data());
    DestroyAudioAccessor(accessor);

    chanmode(initial_chanmode);

    m_audiobuf = InterleavedToMultichannel(buffer.data(), m_nch, m_frames);
}