audio_playback.hpp

Go to the documentation of this file.

#pragma once
 
#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"
#include <chrono>
#include <future>
#include <iostream>
#include <mutex>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#include <sstream>

struct AudioDevice
{
  std::string  name; 
  ma_device_id id;   
};

class MiniAudioPlayer
{
private:
  ma_engine        engine; 
  ma_sound         sound;  
  ma_device        device;
  ma_context       context;
  ma_engine_config engine_config;
  ma_device_id     deviceID; 
  ma_device_config deviceConfig;
  ma_sound_config  soundConfig;
  bool             isPlaying; 
  bool             deviceSet; 
  bool             wasPaused; 
  uint64_t    pausePosition;  
  std::thread playbackThread,
    audioDeviceThread; 
  std::mutex mtx, devicesMutex; 
  std::vector<AudioDevice> devices;
 
public:
  MiniAudioPlayer() : isPlaying(false), wasPaused(false), pausePosition(0), deviceSet(false)
  {
    engine_config = ma_engine_config_init();
    if (ma_engine_init(&engine_config, &engine) != MA_SUCCESS)
    {
      throw std::runtime_error("Failed to initialize MiniAudio engine.");
    }
 
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    if (ma_context_init(nullptr, 0, nullptr, &context) != MA_SUCCESS)
    {
      throw std::runtime_error("Failed to initialize audio context.");
    }
 
    if (ma_device_init(nullptr, &deviceConfig, &device) != MA_SUCCESS)
    {
      throw std::runtime_error("Failed to initialize playback device.");
    }
 
    if (ma_device_start(&device) != MA_SUCCESS)
    {
      ma_device_uninit(&device);
      throw std::runtime_error("Failed to start playback device.");
    }
  }

  ~MiniAudioPlayer()
  {
    stop();
    ma_device_uninit(&device);
    ma_context_uninit(&context);
    ma_engine_uninit(&engine);
  }
 
  auto enumerateDevices() -> std::vector<AudioDevice>
  {
    std::vector<AudioDevice> localDevices;
 
    audioDeviceThread = std::thread(
      [this, &localDevices]()
      {
        try
        {
          ma_device_info* playbackDevices;
          ma_uint32       playbackDeviceCount;
 
          // Enumerate devices
          ma_result result = ma_context_get_devices(&context, &playbackDevices,
                                                    &playbackDeviceCount, nullptr, nullptr);
          if (result != MA_SUCCESS)
          {
            throw std::runtime_error("Failed to enumerate playback devices.");
          }
 
          // Safely copy devices
          {
            std::lock_guard<std::mutex> lock(devicesMutex);
            devices.clear();
            for (ma_uint32 i = 0; i < playbackDeviceCount; ++i)
            {
              devices.push_back({playbackDevices[i].name, playbackDevices[i].id});
            }
            localDevices = devices;
          }
        }
        catch (const std::exception& e)
        {
          std::cerr << "Error in enumerateDevices thread: " << e.what() << "\n";
        }
      });
 
    if (audioDeviceThread.joinable())
      audioDeviceThread.join(); // Wait for the thread to finish
    return localDevices;
  }

  // This does not work will figure some way to fix this
  /*void setDevice(const ma_device_id& id)*/
  /*{*/
  /*    std::unique_lock<std::mutex> lock(mtx);*/
  /**/
  /*    if (!deviceSet) {*/
  /*        std::cerr << "Device not initialized!\n";*/
  /*        return;*/
  /*    }*/
  /**/
  /*    // Stop current playback*/
  /*    ma_device_stop(&device);*/
  /**/
  /*    // Set new device*/
  /*    deviceID                        = id;*/
  /*    deviceConfig.playback.pDeviceID = &deviceID;*/
  /**/
  /*    // Restart playback*/
  /*    if (ma_device_start(&device) != MA_SUCCESS) {*/
  /*        std::cerr << "Failed to restart audio device after switch.\n";*/
  /*    }*/
  /*}*/

  auto loadFileAsync(const std::string& filePath, bool reloadNextFile) -> std::future<int>
  {
    return std::async(std::launch::async,
                      [this, filePath, reloadNextFile]()
                      {
                        std::unique_lock<std::mutex> lock(mtx);
 
                        if (isPlaying)
                        {
                          stop();
                        }
 
                        // File check is done before loading the file so this seems like an
                        // unnecessary sanity check that can be removed
                        /*if (!std::filesystem::exists(filePath))*/
                        /*{*/
                        /*    throw std::runtime_error("File does not exist: " + filePath);*/
                        /*}*/
 
                        if (reloadNextFile)
                        {
                          ma_sound_uninit(&sound);
                        }
 
                        if (deviceSet)
                        {
                          deviceConfig.playback.pDeviceID = &deviceID;
                        }
 
                        if (ma_sound_init_from_file(&engine, filePath.c_str(), MA_SOUND_FLAG_STREAM,
                                                    nullptr, nullptr, &sound) != MA_SUCCESS)
                        {
                          throw std::runtime_error("Failed to load audio file: " + filePath);
                        }
 
                        return 0; // Success
                      });
  }

  void play()
  {
    std::unique_lock<std::mutex> lock(mtx); // Protect shared state
    deviceConfig.playback.pDeviceID = &deviceID;
    if (!isPlaying)
    {
      if (ma_sound_start(&sound) != MA_SUCCESS)
      {
        throw std::runtime_error("Failed to play the sound.");
      }
      isPlaying = true;
 
      if (playbackThread.joinable())
        playbackThread.join();
 
      // Start a new playback thread
      playbackThread = std::thread(
        [this]()
        {
          while (isPlaying)
          {
            if (!ma_sound_is_playing(&sound))
            {
              std::unique_lock<std::mutex> lock(mtx); // Protect shared state
              isPlaying = false;
              break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
          }
        });
    }
    mtx.unlock();
  }

  void pause()
  {
    std::unique_lock<std::mutex> lock(mtx); // Protect shared state
    if (isPlaying)
    {
      // Store the current position before stopping
      pausePosition = ma_sound_get_time_in_pcm_frames(&sound);
 
      if (ma_sound_stop(&sound) != MA_SUCCESS)
      {
        throw std::runtime_error("Failed to pause the sound.");
      }
      isPlaying = false;
      wasPaused = true;
 
      if (playbackThread.joinable())
      {
        playbackThread.join();
      }
    }
    else
    {
      throw std::runtime_error("No song is playing...");
    }
  }

  void resume()
  {
    if (wasPaused)
    {
      // Seek to the stored position and start playing again
      ma_sound_seek_to_pcm_frame(&sound, pausePosition);
      play(); // Call play() to resume playback from the correct position
      wasPaused = false;
    }
  }

  void stop()
  {
    std::unique_lock<std::mutex> lock(mtx); // Protect shared state
    if (isPlaying)
    {
      if (ma_sound_stop(&sound) != MA_SUCCESS)
      {
        throw std::runtime_error("Failed to stop the sound.");
      }
      isPlaying = false;
      ma_sound_seek_to_pcm_frame(&sound, 0);
    }
 
    if (playbackThread.joinable())
    {
      playbackThread.join();
    }
  }

  void setVolume(float volume)
  {
    if (volume < 0.0f || volume > 1.0f)
    {
      throw std::invalid_argument("Volume must be between 0.0 and 1.0.");
    }
    ma_sound_set_volume(&sound, volume);
  }

  [[nodiscard]] auto getVolume() const -> float { return ma_sound_get_volume(&sound); }

  auto isCurrentlyPlaying() -> bool
  {
    std::unique_lock<std::mutex> lock(mtx); // Protect shared state
    return isPlaying;
  }

  auto getDurationAsync() -> std::future<float>
  {
    return std::async(std::launch::async,
                      [this]()
                      {
                        std::unique_lock<std::mutex> lock(mtx); // Protect shared state
                        if (ma_sound_get_time_in_milliseconds(&sound) != MA_SUCCESS)
                        {
                          throw std::runtime_error("Failed to get sound duration.");
                        }
 
                        float     duration = 0.0f;
                        ma_result result   = ma_sound_get_length_in_seconds(&sound, &duration);
                        if (result != MA_SUCCESS)
                        {
                          throw std::runtime_error("Failed to get sound duration. Result: " +
                                                   std::to_string(result));
                        }
 
                        return duration;
                      });
  }

  auto seekTime(int seconds) -> double
  {
    if (isPlaying)
    {
      std::unique_lock<std::mutex> lock(mtx); // Protect shared state
 
      // Get the sample rate of the sound
      ma_uint32 sampleRate = ma_engine_get_sample_rate(&engine);
 
      // Get the total length of the sound in PCM frames
      ma_uint64 totalFrames;
      ma_result result = ma_sound_get_length_in_pcm_frames(&sound, &totalFrames);
      if (result != MA_SUCCESS)
      {
        std::cerr << "Failed to get total PCM frames." << std::endl;
      }
 
      // Get the current position in PCM frames
      ma_uint64 currentFrames = ma_sound_get_time_in_pcm_frames(&sound);
 
      // Calculate the new position in PCM frames
      ma_int64 newFrames =
        static_cast<ma_int64>(currentFrames) + static_cast<ma_int64>(seconds) * sampleRate;
 
      // Clamp the new position to valid bounds
      if (newFrames < 0)
        newFrames = seconds = 0;
      if (static_cast<ma_uint64>(newFrames) > totalFrames)
        newFrames = totalFrames;
 
      result = ma_sound_seek_to_pcm_frame(&sound, static_cast<ma_uint64>(newFrames));
      if (result != MA_SUCCESS)
      {
        std::cerr << "Failed to seek sound." << std::endl;
      }
 
      return (double)seconds;
    }
    else
    {
      throw std::runtime_error("-- Audio is not playing, cannot seek time");
    }
  }

  [[nodiscard]] auto getAudioPlaybackDetails() const -> std::vector<std::string>
  {
    std::vector<std::string> details;
 
    // Get audio engine's sample rate
    ma_uint32 sampleRate = ma_engine_get_sample_rate(&engine);
    if (sampleRate == 0)
    {
      details.emplace_back("WARNING: Could not detect sample rate, using default 44100 Hz");
      sampleRate = 44100;
    }
 
    // Get channels from the device config
    ma_uint32 channels = deviceConfig.playback.channels;
    if (channels == 0)
    {
      details.emplace_back("WARNING: Could not detect channels, using default stereo");
      channels = 2;
    }
 
    // Get format from the device config
    ma_format format = deviceConfig.playback.format;
    if (format == ma_format_unknown)
    {
      details.emplace_back("WARNING: Could not detect format, using default f32");
      format = ma_format_f32;
    }
 
    // Header
    details.emplace_back("=== Audio Playback Details ===");
 
    // Audio Configuration
    details.emplace_back("\nAudio Configuration:");
    {
      std::ostringstream oss;
      oss << "  Sample Rate: " << sampleRate << " Hz";
      details.emplace_back(oss.str());
 
      oss.str("");
      oss << "  Channels: " << channels << " (" << getChannelLayoutString(channels) << ")";
      details.emplace_back(oss.str());
 
      oss.str("");
      oss << "  Format: " << getFormatString(format) << " (" << getBitsPerSample(format) << "-bit)";
      details.emplace_back(oss.str());
    }
 
    // Playback State
    details.emplace_back("\nPlayback State:");
    {
      std::ostringstream oss;
      oss << "  Status: " << getPlaybackStateString();
      details.emplace_back(oss.str());
      oss.str("");
      oss << "  Looping: " << (soundConfig.isLooping ? "Yes" : "No");
      details.emplace_back(oss.str());
    }
 
    return details;
  }
 
  // Helper functions remain the same
  [[nodiscard]] auto getChannelLayoutString(ma_uint32 channels) const -> std::string
  {
    switch (channels)
    {
      case 1:
        return "Mono";
      case 2:
        return "Stereo";
      case 3:
        return "2.1";
      case 4:
        return "Quadraphonic";
      case 5:
        return "5.0";
      case 6:
        return "5.1";
      case 7:
        return "6.1";
      case 8:
        return "7.1";
      default:
      {
        std::ostringstream oss;
        oss << channels << " channels";
        return oss.str();
      }
    }
  }
 
  [[nodiscard]] auto getFormatString(ma_format format) const -> std::string
  {
    switch (format)
    {
      case ma_format_f32:
        return "32-bit float";
      case ma_format_s16:
        return "16-bit signed PCM";
      case ma_format_u8:
        return "8-bit unsigned PCM";
      case ma_format_s24:
        return "24-bit signed PCM";
      case ma_format_s32:
        return "32-bit signed PCM";
      default:
        return "Unknown format";
    }
  }
 
  [[nodiscard]] auto getBitsPerSample(ma_format format) const -> uint32_t
  {
    switch (format)
    {
      case ma_format_f32:
        return 32;
      case ma_format_s16:
        return 16;
      case ma_format_u8:
        return 8;
      case ma_format_s24:
        return 24;
      case ma_format_s32:
        return 32;
      default:
        return 0;
    }
  }
 
  [[nodiscard]] auto getPlaybackStateString() const -> std::string
  {
    if (isPlaying)
      return "Playing";
    if (wasPaused)
      return "Paused";
    return "Stopped";
  }
};