Source repositoryaudio.h

Go to the documentation of this file.

#pragma once
 
// local includes
#include "platform/common.h"
#include "thread_safe.h"
#include "utility.h"
 
#include <array>
#include <bitset>
#include <string_view>
#include <vector>
 
namespace stream {
  struct session_t;
}
 
namespace audio {
  enum stream_config_e : int {
    STEREO,  
    HIGH_STEREO,  
    SURROUND51,  
    HIGH_SURROUND51,  
    SURROUND71,  
    HIGH_SURROUND71,  
    MAX_STREAM_CONFIG  
  };

  struct opus_stream_config_t {
    std::int32_t sampleRate;  
    int channelCount;  
    int streams;  
    int coupledStreams;  
    const std::uint8_t *mapping;  
    int bitrate;  
  };

  struct stream_params_t {
    int channelCount;  
    int streams;  
    int coupledStreams;  
    std::array<std::uint8_t, 8> mapping;  
  };

  extern const std::array<opus_stream_config_t, MAX_STREAM_CONFIG> stream_configs;

  struct config_t {
    enum flags_e : int {
      HIGH_QUALITY,  
      HOST_AUDIO,  
      CUSTOM_SURROUND_PARAMS,  
      CONTINUOUS_AUDIO,  
      MAX_FLAGS  
    };
 
    int packetDuration;  
    int channels;  
    int mask;  
 
    stream_params_t customStreamParams;  
 
    std::bitset<MAX_FLAGS> flags;  
 
    bool use_ac3 {false};  
    bool use_eac3 {false};  
    bool high_quality_dolby {false};  
  };

  struct audio_ctx_t {
    // We want to change the sink for the first stream only
    std::unique_ptr<std::atomic_bool> sink_flag;  
 
    std::unique_ptr<platf::audio_control_t> control;  
 
    bool restore_sink;  
    platf::sink_t sink;  
  };

  using buffer_t = util::buffer_t<std::uint8_t>;
  using packet_t = std::pair<stream::session_t *, buffer_t>;
  using audio_ctx_ref_t = safe::shared_t<audio_ctx_t>::ptr_t;

  void capture(safe::mail_t mail, config_t config, stream::session_t *channel_data);

  audio_ctx_ref_t get_audio_ctx_ref();

  bool is_audio_ctx_sink_available(const audio_ctx_t &ctx);

  bool ac3_available();

  bool eac3_available();

  enum class dolby_codec_e {
    opus,  
    ac3,  
    eac3  
  };

  dolby_codec_e configure_dolby_audio(
    config_t &config,
    std::string_view offered,
    std::string_view accepted,
    bool ac3_encoder_available,
    bool eac3_encoder_available,
    bool high_quality
  );

  std::string_view dolby_codec_name(dolby_codec_e codec);
 
#ifdef SUNSHINE_TESTS
  int encode_dolby_frame_for_testing(
    bool eac3,
    bool high_quality,
    int channels,
    const std::vector<float> &interleaved,
    buffer_t &output
  );
#endif

  int dolby_bitrate_kbps(bool eac3, bool high_quality, int channels);
}  // namespace audio