media/cast/cast_sender_impl.cc

   1 // Copyright 2013 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 "media/cast/cast_sender_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "media/base/video_frame.h"
  12 #include "media/cast/net/rtcp/rtcp_receiver.h"
  13
  14 namespace media {
  15 namespace cast {
  16
  17 // The LocalVideoFrameInput class posts all incoming video frames to the main
  18 // cast thread for processing.
  19 class LocalVideoFrameInput : public VideoFrameInput {
  20  public:
  21   LocalVideoFrameInput(scoped_refptr<CastEnvironment> cast_environment,
  22                        base::WeakPtr<VideoSender> video_sender)
  23       : cast_environment_(cast_environment), video_sender_(video_sender) {}
  24
  25   virtual void InsertRawVideoFrame(
  26       const scoped_refptr<media::VideoFrame>& video_frame,
  27       const base::TimeTicks& capture_time) OVERRIDE {
  28     cast_environment_->PostTask(CastEnvironment::MAIN,
  29                                 FROM_HERE,
  30                                 base::Bind(&VideoSender::InsertRawVideoFrame,
  31                                            video_sender_,
  32                                            video_frame,
  33                                            capture_time));
  34   }
  35
  36  protected:
  37   virtual ~LocalVideoFrameInput() {}
  38
  39  private:
  40   friend class base::RefCountedThreadSafe<LocalVideoFrameInput>;
  41
  42   scoped_refptr<CastEnvironment> cast_environment_;
  43   base::WeakPtr<VideoSender> video_sender_;
  44
  45   DISALLOW_COPY_AND_ASSIGN(LocalVideoFrameInput);
  46 };
  47
  48 // The LocalAudioFrameInput class posts all incoming audio frames to the main
  49 // cast thread for processing. Therefore frames can be inserted from any thread.
  50 class LocalAudioFrameInput : public AudioFrameInput {
  51  public:
  52   LocalAudioFrameInput(scoped_refptr<CastEnvironment> cast_environment,
  53                        base::WeakPtr<AudioSender> audio_sender)
  54       : cast_environment_(cast_environment), audio_sender_(audio_sender) {}
  55
  56   virtual void InsertAudio(scoped_ptr<AudioBus> audio_bus,
  57                            const base::TimeTicks& recorded_time) OVERRIDE {
  58     cast_environment_->PostTask(CastEnvironment::MAIN,
  59                                 FROM_HERE,
  60                                 base::Bind(&AudioSender::InsertAudio,
  61                                            audio_sender_,
  62                                            base::Passed(&audio_bus),
  63                                            recorded_time));
  64   }
  65
  66  protected:
  67   virtual ~LocalAudioFrameInput() {}
  68
  69  private:
  70   friend class base::RefCountedThreadSafe<LocalAudioFrameInput>;
  71
  72   scoped_refptr<CastEnvironment> cast_environment_;
  73   base::WeakPtr<AudioSender> audio_sender_;
  74
  75   DISALLOW_COPY_AND_ASSIGN(LocalAudioFrameInput);
  76 };
  77
  78 scoped_ptr<CastSender> CastSender::Create(
  79     scoped_refptr<CastEnvironment> cast_environment,
  80     CastTransportSender* const transport_sender) {
  81   CHECK(cast_environment);
  82   return scoped_ptr<CastSender>(
  83       new CastSenderImpl(cast_environment, transport_sender));
  84 }
  85
  86 CastSenderImpl::CastSenderImpl(
  87     scoped_refptr<CastEnvironment> cast_environment,
  88     CastTransportSender* const transport_sender)
  89     : cast_environment_(cast_environment),
  90       transport_sender_(transport_sender),
  91       weak_factory_(this) {
  92   CHECK(cast_environment);
  93 }
  94
  95 void CastSenderImpl::InitializeAudio(
  96     const AudioSenderConfig& audio_config,
  97     const CastInitializationCallback& cast_initialization_cb) {
  98   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
  99   CHECK(audio_config.use_external_encoder ||
 100         cast_environment_->HasAudioThread());
 101
 102   VLOG(1) << "CastSenderImpl@" << this << "::InitializeAudio()";
 103
 104   audio_sender_.reset(
 105       new AudioSender(cast_environment_, audio_config, transport_sender_));
 106
 107   const CastInitializationStatus status = audio_sender_->InitializationResult();
 108   if (status == STATUS_AUDIO_INITIALIZED) {
 109     ssrc_of_audio_sender_ = audio_config.incoming_feedback_ssrc;
 110     audio_frame_input_ =
 111         new LocalAudioFrameInput(cast_environment_, audio_sender_->AsWeakPtr());
 112   }
 113   cast_initialization_cb.Run(status);
 114 }
 115
 116 void CastSenderImpl::InitializeVideo(
 117     const VideoSenderConfig& video_config,
 118     const CastInitializationCallback& cast_initialization_cb,
 119     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
 120     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb) {
 121   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 122   CHECK(video_config.use_external_encoder ||
 123         cast_environment_->HasVideoThread());
 124
 125   VLOG(1) << "CastSenderImpl@" << this << "::InitializeVideo()";
 126
 127   video_sender_.reset(new VideoSender(cast_environment_,
 128                                       video_config,
 129                                       create_vea_cb,
 130                                       create_video_encode_mem_cb,
 131                                       transport_sender_));
 132
 133   const CastInitializationStatus status = video_sender_->InitializationResult();
 134   if (status == STATUS_VIDEO_INITIALIZED) {
 135     ssrc_of_video_sender_ = video_config.incoming_feedback_ssrc;
 136     video_frame_input_ =
 137         new LocalVideoFrameInput(cast_environment_, video_sender_->AsWeakPtr());
 138   }
 139   cast_initialization_cb.Run(status);
 140 }
 141
 142 CastSenderImpl::~CastSenderImpl() {
 143   VLOG(1) << "CastSenderImpl@" << this << "::~CastSenderImpl()";
 144 }
 145
 146 scoped_refptr<AudioFrameInput> CastSenderImpl::audio_frame_input() {
 147   return audio_frame_input_;
 148 }
 149
 150 scoped_refptr<VideoFrameInput> CastSenderImpl::video_frame_input() {
 151   return video_frame_input_;
 152 }
 153
 154 }  // namespace cast
 155 }  // namespace media