clip.h

// SPDX-FileCopyrightText: © 2019-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "utils/audio.h"
#include "utils/audio_file.h"
#include "utils/hash.h"
#include "utils/icloneable.h"
#include "utils/monotonic_time_provider.h"
#include "utils/serialization.h"
#include "utils/types.h"
#include "utils/uuid_identifiable_object.h"
 
using namespace zrythm;

class AudioClip final
    : public utils::UuidIdentifiableObject<AudioClip>,
      private utils::QElapsedTimeProvider
{
public:
  using BitDepth = zrythm::utils::audio::BitDepth;
  using AudioFile = zrythm::utils::audio::AudioFile;
 
public:
  AudioClip () = default;

  AudioClip (
    const fs::path &full_path,
    sample_rate_t   project_sample_rate,
    bpm_t           current_bpm);

  AudioClip (
    const utils::audio::AudioBuffer &buf,
    utils::audio::BitDepth           bit_depth,
    sample_rate_t                    project_sample_rate,
    bpm_t                            current_bpm,
    const utils::Utf8String         &name);

  AudioClip (
    const float *                  arr,
    unsigned_frame_t               nframes,
    channels_t                     channels,
    zrythm::utils::audio::BitDepth bit_depth,
    sample_rate_t                  project_sample_rate,
    bpm_t                          current_bpm,
    const utils::Utf8String       &name)
      : AudioClip (
          *utils::audio::AudioBuffer::from_interleaved (arr, nframes, channels),
          bit_depth,
          project_sample_rate,
          current_bpm,
          name)
  {
  }

  AudioClip (
    channels_t               channels,
    unsigned_frame_t         nframes,
    sample_rate_t            project_sample_rate,
    bpm_t                    current_bpm,
    const utils::Utf8String &name);
 
public:
  static bool should_use_flac (zrythm::utils::audio::BitDepth bd)
  {
    return false;
    /* FLAC seems to fail writing sometimes so disable for now */
#if 0
  return bd < BIT_DEPTH_32;
#endif
  }
 
  friend void init_from (
    AudioClip             &obj,
    const AudioClip       &other,
    utils::ObjectCloneType clone_type);

  void init_loaded (const fs::path &full_path);

  std::unique_ptr<AudioClip> edit_in_ext_program ();

  void write_to_file (const fs::path &filepath, bool parts);
 
  auto        get_bit_depth () const { return bit_depth_; }
  auto        get_name () const { return name_; }
  auto        get_file_hash () const { return file_hash_; }
  auto        get_bpm () const { return bpm_; }
  const auto &get_samples () const { return ch_frames_; }
  auto        get_last_write_to_file () const { return last_write_; }
  auto        get_use_flac () const { return use_flac_; }
 
  void set_name (const utils::Utf8String &name) { name_ = name; }
  void set_file_hash (utils::hash::HashT hash) { file_hash_ = hash; }

  void expand_with_frames (const utils::audio::AudioBuffer &frames);

  void replace_frames (
    const utils::audio::AudioBuffer &src_frames,
    unsigned_frame_t                 start_frame);

  void replace_frames_from_interleaved (
    const float *    frames,
    unsigned_frame_t start_frame,
    unsigned_frame_t num_frames_per_channel,
    channels_t       channels);

  void clear_frames ()
  {
    ch_frames_.setSize (ch_frames_.getNumChannels (), 0, false, true);
  }
 
  auto get_num_channels () const { return ch_frames_.getNumChannels (); };
  auto get_num_frames () const { return ch_frames_.getNumSamples (); };

  void finalize_buffered_write ();

  bool verify_recorded_file (
    const fs::path &filepath,
    sample_rate_t   project_sample_rate,
    bpm_t           current_bpm) const;

  bool enough_time_elapsed_since_last_write () const;
 
private:
  static constexpr auto kNameKey = "name"sv;
  static constexpr auto kFileHashKey = "fileHash"sv;
  static constexpr auto kBpmKey = "bpm"sv;
  static constexpr auto kBitDepthKey = "bitDepth"sv;
  static constexpr auto kUseFlacKey = "useFlac"sv;
  static constexpr auto kSamplerateKey = "samplerate"sv;
  friend void           to_json (nlohmann::json &j, const AudioClip &clip)
  {
    to_json (j, static_cast<const UuidIdentifiableObject &> (clip));
    j[kNameKey] = clip.name_;
    j[kFileHashKey] = clip.file_hash_;
    j[kBpmKey] = clip.bpm_;
    j[kBitDepthKey] = clip.bit_depth_;
    j[kUseFlacKey] = clip.use_flac_;
    j[kSamplerateKey] = clip.samplerate_;
  }
  friend void from_json (const nlohmann::json &j, AudioClip &clip)
  {
    from_json (j, static_cast<UuidIdentifiableObject &> (clip));
    j.at (kNameKey).get_to (clip.name_);
    j.at (kFileHashKey).get_to (clip.file_hash_);
    j.at (kBpmKey).get_to (clip.bpm_);
    j.at (kBitDepthKey).get_to (clip.bit_depth_);
    j.at (kUseFlacKey).get_to (clip.use_flac_);
    j.at (kSamplerateKey).get_to (clip.samplerate_);
  }

  void init_from_file (
    const fs::path      &full_path,
    sample_rate_t        project_sample_rate,
    std::optional<bpm_t> bpm_to_set);
 
private:
  utils::Utf8String name_;

  utils::audio::AudioBuffer ch_frames_;

  bpm_t bpm_{};

  sample_rate_t samplerate_{};

  utils::audio::BitDepth bit_depth_{};

  bool use_flac_{ false };

  utils::hash::HashT file_hash_{};

  unsigned_frame_t frames_written_{};

  utils::MonotonicTime last_write_{};

  std::unique_ptr<juce::AudioFormatWriter> writer_;
  std::optional<fs::path>                  writer_path_;
};
 
using AudioClipResolverFunc =
  std::function<AudioClip *(const AudioClip::Uuid &clip_id)>;
using RegisterNewAudioClipFunc =
  std::function<void (std::shared_ptr<AudioClip>)>;
 
DEFINE_UUID_HASH_SPECIALIZATION (AudioClip::Uuid)