git.sesse.net Git - casparcg/blob - modules/oal/consumer/oal_consumer.cpp

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Robert Nagy, ronag89@gmail.com
  20 */
  21
  22 #include "oal_consumer.h"
  23
  24 #include <common/except.h>
  25 #include <common/executor.h>
  26 #include <common/diagnostics/graph.h>
  27 #include <common/log.h>
  28 #include <common/utf.h>
  29 #include <common/env.h>
  30 #include <common/future.h>
  31
  32 #include <core/consumer/frame_consumer.h>
  33 #include <core/frame/frame.h>
  34 #include <core/mixer/audio/audio_util.h>
  35 #include <core/mixer/audio/audio_mixer.h>
  36 #include <core/video_format.h>
  37
  38 #include <boost/circular_buffer.hpp>
  39 #include <boost/lexical_cast.hpp>
  40 #include <boost/property_tree/ptree.hpp>
  41 #include <boost/timer.hpp>
  42 #include <boost/thread/once.hpp>
  43
  44 #include <tbb/concurrent_queue.h>
  45
  46 #include <al/alc.h>
  47 #include <al/al.h>
  48
  49 #include <array>
  50
  51 namespace caspar { namespace oal {
  52
  53 typedef std::vector<int16_t, tbb::cache_aligned_allocator<int16_t>> audio_buffer_16;
  54
  55 class device
  56 {
  57         ALCdevice*                                                                                      device_;
  58         ALCcontext*                                                                                     context_;
  59
  60 public:
  61         device()
  62                 : device_(0)
  63                 , context_(0)
  64         {
  65                 device_ = alcOpenDevice(nullptr);
  66
  67                 if(!device_)
  68                         CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Failed to initialize audio device."));
  69
  70                 context_ = alcCreateContext(device_, nullptr);
  71
  72                 if(!context_)
  73                         CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Failed to create audio context."));
  74
  75                 if(alcMakeContextCurrent(context_) == ALC_FALSE)
  76                         CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Failed to activate audio context."));
  77         }
  78
  79         ~device()
  80         {
  81                 alcMakeContextCurrent(nullptr);
  82
  83                 if(context_)
  84                         alcDestroyContext(context_);
  85
  86                 if(device_)
  87                         alcCloseDevice(device_);
  88         }
  89
  90         ALCdevice* get()
  91         {
  92                 return device_;
  93         }
  94 };
  95
  96 void init_device()
  97 {
  98         static std::unique_ptr<device> instance;
  99         static boost::once_flag f = BOOST_ONCE_INIT;
 100
 101         boost::call_once(f, []{instance.reset(new device());});
 102 }
 103
 104 struct oal_consumer : public core::frame_consumer
 105 {
 106         core::monitor::subject                          monitor_subject_;
 107
 108         spl::shared_ptr<diagnostics::graph>     graph_;
 109         boost::timer                                            perf_timer_;
 110         int                                                                     channel_index_;
 111
 112         core::video_format_desc                         format_desc_;
 113
 114         ALuint                                                          source_;
 115         std::array<ALuint, 3>                           buffers_;
 116
 117         executor                                                        executor_;
 118
 119 public:
 120         oal_consumer()
 121                 : channel_index_(-1)
 122                 , source_(0)
 123                 , executor_(L"oal_consumer")
 124         {
 125                 buffers_.assign(0);
 126
 127                 init_device();
 128
 129                 graph_->set_color("tick-time", diagnostics::color(0.0f, 0.6f, 0.9f));
 130                 graph_->set_color("dropped-frame", diagnostics::color(0.3f, 0.6f, 0.3f));
 131                 graph_->set_color("late-frame", diagnostics::color(0.6f, 0.3f, 0.3f));
 132                 diagnostics::register_graph(graph_);
 133         }
 134
 135         ~oal_consumer()
 136         {
 137                 executor_.begin_invoke([=]
 138                 {
 139                         if(source_)
 140                         {
 141                                 alSourceStop(source_);
 142                                 alDeleteSources(1, &source_);
 143                         }
 144
 145                         for (auto& buffer : buffers_)
 146                         {
 147                                 if(buffer)
 148                                         alDeleteBuffers(1, &buffer);
 149                         };
 150                 });
 151         }
 152
 153         // frame consumer
 154
 155         void initialize(const core::video_format_desc& format_desc, int channel_index) override
 156         {
 157                 format_desc_    = format_desc;
 158                 channel_index_  = channel_index;
 159                 graph_->set_text(print());
 160
 161                 executor_.begin_invoke([=]
 162                 {
 163                         alGenBuffers(static_cast<ALsizei>(buffers_.size()), buffers_.data());
 164                         alGenSources(1, &source_);
 165
 166                         for(std::size_t n = 0; n < buffers_.size(); ++n)
 167                         {
 168                                 std::vector<int16_t> audio(format_desc_.audio_cadence[n % format_desc_.audio_cadence.size()]*format_desc_.audio_channels, 0);
 169                                 alBufferData(buffers_[n], AL_FORMAT_STEREO16, audio.data(), static_cast<ALsizei>(audio.size()*sizeof(int16_t)), format_desc_.audio_sample_rate);
 170                                 alSourceQueueBuffers(source_, 1, &buffers_[n]);
 171                         }
 172
 173                         alSourcei(source_, AL_LOOPING, AL_FALSE);
 174
 175                         alSourcePlay(source_);
 176                 });
 177         }
 178
 179         std::future<bool> send(core::const_frame frame) override
 180         {
 181                 // Will only block if the default executor queue capacity of 512 is
 182                 // exhausted, which should not happen
 183                 executor_.begin_invoke([=]
 184                 {
 185                         ALenum state;
 186                         alGetSourcei(source_, AL_SOURCE_STATE,&state);
 187                         if(state != AL_PLAYING)
 188                         {
 189                                 for(int n = 0; n < buffers_.size()-1; ++n)
 190                                 {
 191                                         ALuint buffer = 0;
 192                                         alSourceUnqueueBuffers(source_, 1, &buffer);
 193                                         if(buffer)
 194                                         {
 195                                                 std::vector<int16_t> audio(format_desc_.audio_cadence[n % format_desc_.audio_cadence.size()] * format_desc_.audio_channels, 0);
 196                                                 alBufferData(buffer, AL_FORMAT_STEREO16, audio.data(), static_cast<ALsizei>(audio.size()*sizeof(int16_t)), format_desc_.audio_sample_rate);
 197                                                 alSourceQueueBuffers(source_, 1, &buffer);
 198                                         }
 199                                 }
 200                                 alSourcePlay(source_);
 201                                 graph_->set_tag("late-frame");
 202                         }
 203
 204                         auto audio = core::audio_32_to_16(frame.audio_data());
 205
 206                         ALuint buffer = 0;
 207                         alSourceUnqueueBuffers(source_, 1, &buffer);
 208                         if(buffer)
 209                         {
 210                                 alBufferData(buffer, AL_FORMAT_STEREO16, audio.data(), static_cast<ALsizei>(audio.size()*sizeof(int16_t)), format_desc_.audio_sample_rate);
 211                                 alSourceQueueBuffers(source_, 1, &buffer);
 212                         }
 213                         else
 214                                 graph_->set_tag("dropped-frame");
 215
 216                         graph_->set_value("tick-time", perf_timer_.elapsed()*format_desc_.fps*0.5);
 217                         perf_timer_.restart();
 218                 });
 219
 220                 return make_ready_future(true);
 221         }
 222
 223         std::wstring print() const override
 224         {
 225                 return L"oal[" + boost::lexical_cast<std::wstring>(channel_index_) + L"|" + format_desc_.name + L"]";
 226         }
 227
 228         std::wstring name() const override
 229         {
 230                 return L"system-audio";
 231         }
 232
 233         boost::property_tree::wptree info() const override
 234         {
 235                 boost::property_tree::wptree info;
 236                 info.add(L"type", L"system-audio");
 237                 return info;
 238         }
 239
 240         bool has_synchronization_clock() const override
 241         {
 242                 return false;
 243         }
 244
 245         int delay_millis() const
 246         {
 247                 return 60;
 248         }
 249
 250         int buffer_depth() const override
 251         {
 252                 int delay_in_frames = static_cast<int>(delay_millis() / (1000.0 / format_desc_.fps));
 253
 254                 return delay_in_frames;
 255         }
 256
 257         int index() const override
 258         {
 259                 return 500;
 260         }
 261
 262         core::monitor::subject& monitor_output()
 263         {
 264                 return monitor_subject_;
 265         }
 266 };
 267
 268 spl::shared_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)
 269 {
 270         if(params.size() < 1 || params[0] != L"AUDIO")
 271                 return core::frame_consumer::empty();
 272
 273         return spl::make_shared<oal_consumer>();
 274 }
 275
 276 spl::shared_ptr<core::frame_consumer> create_consumer()
 277 {
 278         return spl::make_shared<oal_consumer>();
 279 }
 280
 281 }}