Piping for audio encoding.

remoting/host/chromoting_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
+#include "remoting/codec/audio_encoder.h"
+#include "remoting/codec/audio_encoder_verbatim.h"
 #include "remoting/host/audio_scheduler.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
@@ skipping 181 matching lines @@
   }
 }
 
 void ChromotingHost::OnSessionChannelsConnected(ClientSession* client) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   // Then we create a ScreenRecorder passing the message loops that
   // it should run on.
   Encoder* encoder = CreateEncoder(client->connection()->session()->config());
 
+  scoped_ptr<AudioEncoder> audio_encoder =

[Sergey Ulanov, 2012/07/31 22:22:17]

Move this below, inside the if statement where you creatae AudioScheduler.

[kxing, 2012/07/31 23:06:06]

Done.

+      CreateAudioEncoder(client->connection()->session()->config());
+
   recorder_ = new ScreenRecorder(context_->capture_task_runner(),
                                  context_->encode_task_runner(),
                                  context_->network_task_runner(),
                                  desktop_environment_->capturer(),
                                  encoder);
   if (client->connection()->session()->config().is_audio_enabled()) {
     audio_scheduler_ = new AudioScheduler(
         context_->capture_task_runner(),
         context_->network_task_runner(),
         desktop_environment_->audio_capturer(),
+        audio_encoder.Pass(),
         client->connection()->audio_stub());
   }
 
   // Immediately add the connection and start the session.
   recorder_->AddConnection(client->connection());
   recorder_->Start();
   desktop_environment_->OnSessionStarted(client->CreateClipboardProxy());
 
   FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
                     OnClientConnected(client->client_jid()));
@@ skipping 173 matching lines @@
     return EncoderRowBased::CreateVerbatimEncoder();
   } else if (video_config.codec == protocol::ChannelConfig::CODEC_ZIP) {
     return EncoderRowBased::CreateZlibEncoder();
   } else if (video_config.codec == protocol::ChannelConfig::CODEC_VP8) {
     return new remoting::EncoderVp8();
   }
 
   return NULL;
 }
 
+// static
+scoped_ptr<AudioEncoder> ChromotingHost::CreateAudioEncoder(
+    const protocol::SessionConfig& config) {
+  const protocol::ChannelConfig& audio_config = config.audio_config();
+
+  if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
+    return AudioEncoderVerbatim::CreateVerbatimAudioEncoder();
+  }
+
+  NOTIMPLEMENTED();
+  return scoped_ptr<AudioEncoder>(NULL);
+}
+
 void ChromotingHost::StopScreenRecorder() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(recorder_.get());
 
   ++stopping_recorders_;
   scoped_refptr<ScreenRecorder> recorder = recorder_;
   recorder_ = NULL;
   recorder->Stop(base::Bind(&ChromotingHost::OnRecorderStopped, this));
 }
 
@@ skipping 36 matching lines @@
                     OnShutdown());
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting