src/components/copresence/handlers/audio/audio_directive_handler.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/copresence/handlers/audio/audio_directive_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/time/time.h"
  12 #include "components/copresence/mediums/audio/audio_player.h"
  13 #include "components/copresence/mediums/audio/audio_recorder.h"
  14 #include "components/copresence/proto/data.pb.h"
  15 #include "media/base/audio_bus.h"
  16
  17 namespace {
  18
  19 // UrlSafe is defined as:
  20 // '/' represented by a '_' and '+' represented by a '-'
  21 // TODO(rkc): Move this processing to the whispernet wrapper.
  22 std::string FromUrlSafe(std::string token) {
  23   base::ReplaceChars(token, "-", "+", &token);
  24   base::ReplaceChars(token, "_", "/", &token);
  25   return token;
  26 }
  27
  28 const int kSampleExpiryTimeMs = 60 * 60 * 1000;  // 60 minutes.
  29 const int kMaxSamples = 10000;
  30
  31 }  // namespace
  32
  33 namespace copresence {
  34
  35 // Public methods.
  36
  37 AudioDirectiveHandler::AudioDirectiveHandler(
  38     const AudioRecorder::DecodeSamplesCallback& decode_cb,
  39     const AudioDirectiveHandler::EncodeTokenCallback& encode_cb)
  40     : player_audible_(NULL),
  41       player_inaudible_(NULL),
  42       recorder_(NULL),
  43       decode_cb_(decode_cb),
  44       encode_cb_(encode_cb),
  45       samples_cache_audible_(
  46           base::TimeDelta::FromMilliseconds(kSampleExpiryTimeMs),
  47           kMaxSamples),
  48       samples_cache_inaudible_(
  49           base::TimeDelta::FromMilliseconds(kSampleExpiryTimeMs),
  50           kMaxSamples) {
  51 }
  52
  53 AudioDirectiveHandler::~AudioDirectiveHandler() {
  54   if (player_audible_)
  55     player_audible_->Finalize();
  56   if (player_inaudible_)
  57     player_inaudible_->Finalize();
  58   if (recorder_)
  59     recorder_->Finalize();
  60 }
  61
  62 void AudioDirectiveHandler::Initialize() {
  63   player_audible_ = new AudioPlayer();
  64   player_audible_->Initialize();
  65
  66   player_inaudible_ = new AudioPlayer();
  67   player_inaudible_->Initialize();
  68
  69   recorder_ = new AudioRecorder(decode_cb_);
  70   recorder_->Initialize();
  71 }
  72
  73 void AudioDirectiveHandler::AddInstruction(const TokenInstruction& instruction,
  74                                            const std::string& op_id,
  75                                            base::TimeDelta ttl) {
  76   switch (instruction.token_instruction_type()) {
  77     case TRANSMIT:
  78       DVLOG(2) << "Audio Transmit Directive received. Token: "
  79                << instruction.token_id()
  80                << " with TTL=" << ttl.InMilliseconds();
  81       switch (instruction.medium()) {
  82         case AUDIO_ULTRASOUND_PASSBAND:
  83           transmits_list_inaudible_.AddDirective(op_id, ttl);
  84           PlayToken(instruction.token_id(), false);
  85           break;
  86         case AUDIO_AUDIBLE_DTMF:
  87           transmits_list_audible_.AddDirective(op_id, ttl);
  88           PlayToken(instruction.token_id(), true);
  89           break;
  90         default:
  91           NOTREACHED();
  92       }
  93       break;
  94     case RECEIVE:
  95       DVLOG(2) << "Audio Receive Directive received. TTL="
  96                << ttl.InMilliseconds();
  97       receives_list_.AddDirective(op_id, ttl);
  98       ProcessNextReceive();
  99       break;
 100     case UNKNOWN_TOKEN_INSTRUCTION_TYPE:
 101     default:
 102       LOG(WARNING) << "Unknown Audio Transmit Directive received.";
 103   }
 104 }
 105
 106 void AudioDirectiveHandler::RemoveInstructions(const std::string& op_id) {
 107   transmits_list_audible_.RemoveDirective(op_id);
 108   transmits_list_inaudible_.RemoveDirective(op_id);
 109   receives_list_.RemoveDirective(op_id);
 110
 111   ProcessNextTransmit();
 112   ProcessNextReceive();
 113 }
 114
 115 // Private methods.
 116
 117 void AudioDirectiveHandler::ProcessNextTransmit() {
 118   // If we have an active directive for audible or inaudible audio, ensure that
 119   // we are playing our respective token; if we do not have a directive, then
 120   // make sure we aren't playing. This is duplicate code, but for just two
 121   // elements, it has hard to make a case for processing a loop instead.
 122
 123   scoped_ptr<AudioDirective> audible_transmit(
 124       transmits_list_audible_.GetActiveDirective());
 125   if (audible_transmit && !player_audible_->IsPlaying() &&
 126       samples_cache_audible_.HasKey(current_token_audible_)) {
 127     DVLOG(3) << "Playing audible for op_id: " << audible_transmit->op_id;
 128     player_audible_->Play(
 129         samples_cache_audible_.GetValue(current_token_audible_));
 130     stop_audible_playback_timer_.Start(
 131         FROM_HERE,
 132         audible_transmit->end_time - base::Time::Now(),
 133         this,
 134         &AudioDirectiveHandler::ProcessNextTransmit);
 135   } else if (!audible_transmit && player_audible_->IsPlaying()) {
 136     DVLOG(3) << "Stopping audible playback.";
 137     current_token_audible_.clear();
 138     stop_audible_playback_timer_.Stop();
 139     player_audible_->Stop();
 140   }
 141
 142   scoped_ptr<AudioDirective> inaudible_transmit(
 143       transmits_list_inaudible_.GetActiveDirective());
 144   if (inaudible_transmit && !player_inaudible_->IsPlaying() &&
 145       samples_cache_inaudible_.HasKey(current_token_inaudible_)) {
 146     DVLOG(3) << "Playing inaudible for op_id: " << inaudible_transmit->op_id;
 147     player_inaudible_->Play(
 148         samples_cache_inaudible_.GetValue(current_token_inaudible_));
 149     stop_inaudible_playback_timer_.Start(
 150         FROM_HERE,
 151         inaudible_transmit->end_time - base::Time::Now(),
 152         this,
 153         &AudioDirectiveHandler::ProcessNextTransmit);
 154   } else if (!inaudible_transmit && player_inaudible_->IsPlaying()) {
 155     DVLOG(3) << "Stopping inaudible playback.";
 156     current_token_inaudible_.clear();
 157     stop_inaudible_playback_timer_.Stop();
 158     player_inaudible_->Stop();
 159   }
 160 }
 161
 162 void AudioDirectiveHandler::ProcessNextReceive() {
 163   scoped_ptr<AudioDirective> receive(receives_list_.GetActiveDirective());
 164
 165   if (receive && !recorder_->IsRecording()) {
 166     DVLOG(3) << "Recording for op_id: " << receive->op_id;
 167     recorder_->Record();
 168     stop_recording_timer_.Start(FROM_HERE,
 169                                 receive->end_time - base::Time::Now(),
 170                                 this,
 171                                 &AudioDirectiveHandler::ProcessNextReceive);
 172   } else if (!receive && recorder_->IsRecording()) {
 173     DVLOG(3) << "Stopping Recording";
 174     stop_recording_timer_.Stop();
 175     recorder_->Stop();
 176   }
 177 }
 178
 179 void AudioDirectiveHandler::PlayToken(const std::string token, bool audible) {
 180   std::string valid_token = FromUrlSafe(token);
 181
 182   // If the token has been encoded already, use the cached samples.
 183   if (audible && samples_cache_audible_.HasKey(valid_token)) {
 184     current_token_audible_ = token;
 185     ProcessNextTransmit();
 186   } else if (!audible && samples_cache_inaudible_.HasKey(valid_token)) {
 187     current_token_inaudible_ = token;
 188     ProcessNextTransmit();
 189   } else {
 190     // Otherwise, encode the token and then play it.
 191     encode_cb_.Run(valid_token,
 192                    audible,
 193                    base::Bind(&AudioDirectiveHandler::PlayEncodedToken,
 194                               base::Unretained(this)));
 195   }
 196 }
 197
 198 void AudioDirectiveHandler::PlayEncodedToken(
 199     const std::string& token,
 200     bool audible,
 201     const scoped_refptr<media::AudioBusRefCounted>& samples) {
 202   DVLOG(3) << "Token " << token << "[audible:" << audible << "] encoded.";
 203   if (audible) {
 204     samples_cache_audible_.Add(token, samples);
 205     current_token_audible_ = token;
 206     // Force process transmits to pick up the new token.
 207     if (player_audible_->IsPlaying())
 208       player_audible_->Stop();
 209   } else {
 210     samples_cache_inaudible_.Add(token, samples);
 211     current_token_inaudible_ = token;
 212     // Force process transmits to pick up the new token.
 213     if (player_inaudible_->IsPlaying())
 214       player_inaudible_->Stop();
 215   }
 216
 217   ProcessNextTransmit();
 218 }
 219
 220 }  // namespace copresence