chrome/renderer/media/cast_receiver_session_delegate.cc

   1 // Copyright 2015 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 "chrome/renderer/media/cast_receiver_session_delegate.h"
   6
   7 #include "base/synchronization/waitable_event.h"
   8 #include "base/values.h"
   9
  10 CastReceiverSessionDelegate::CastReceiverSessionDelegate()
  11     : weak_factory_(this) {
  12 }
  13 CastReceiverSessionDelegate::~CastReceiverSessionDelegate() {}
  14
  15 void CastReceiverSessionDelegate::LogRawEvents(
  16     const std::vector<media::cast::PacketEvent>& packet_events,
  17     const std::vector<media::cast::FrameEvent>& frame_events) {
  18   NOTREACHED();
  19 }
  20
  21 void CastReceiverSessionDelegate::Start(
  22     const media::cast::FrameReceiverConfig& audio_config,
  23     const media::cast::FrameReceiverConfig& video_config,
  24     const net::IPEndPoint& local_endpoint,
  25     const net::IPEndPoint& remote_endpoint,
  26     scoped_ptr<base::DictionaryValue> options,
  27     const media::VideoCaptureFormat& format) {
  28   format_ = format;
  29   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
  30   CastSessionDelegateBase::StartUDP(local_endpoint,
  31                                     remote_endpoint,
  32                                     options.Pass());
  33   cast_receiver_ = media::cast::CastReceiver::Create(cast_environment_,
  34                                                      audio_config,
  35                                                      video_config,
  36                                                      cast_transport_.get());
  37   on_audio_decoded_cb_ = base::Bind(
  38       &CastReceiverSessionDelegate::OnDecodedAudioFrame,
  39       weak_factory_.GetWeakPtr());
  40   on_video_decoded_cb_ = base::Bind(
  41       &CastReceiverSessionDelegate::OnDecodedVideoFrame,
  42       weak_factory_.GetWeakPtr());
  43 }
  44
  45 void CastReceiverSessionDelegate::ReceivePacket(
  46     scoped_ptr<media::cast::Packet> packet) {
  47   cast_receiver_->ReceivePacket(packet.Pass());
  48 }
  49
  50 void CastReceiverSessionDelegate::StartAudio(
  51     scoped_refptr<CastReceiverAudioValve> audio_valve) {
  52   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
  53   audio_valve_ = audio_valve;
  54   cast_receiver_->RequestDecodedAudioFrame(on_audio_decoded_cb_);
  55 }
  56
  57 void CastReceiverSessionDelegate::OnDecodedAudioFrame(
  58     scoped_ptr<media::AudioBus> audio_bus,
  59     const base::TimeTicks& playout_time,
  60     bool is_continous) {
  61   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
  62   if (!audio_valve_)
  63     return;
  64
  65   // We're on the IO thread, which doesn't allow blocking
  66   // operations. Since we don't know what the Capture callback
  67   // will do exactly, we need to jump to a different thread.
  68   // Let's re-use the audio decoder thread.
  69   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
  70   cast_environment_->PostTask(
  71       media::cast::CastEnvironment::AUDIO,
  72       FROM_HERE,
  73       base::Bind(&CastReceiverAudioValve::Capture,
  74                  audio_valve_,
  75                  base::Owned(audio_bus.release()),
  76                  (playout_time - now).InMilliseconds(),
  77                  1.0,
  78                  false));
  79   cast_receiver_->RequestDecodedAudioFrame(on_audio_decoded_cb_);
  80 }
  81
  82 void CastReceiverSessionDelegate::StartVideo(
  83     content::VideoCaptureDeliverFrameCB video_callback) {
  84   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
  85   frame_callback_ = video_callback;
  86   cast_receiver_->RequestDecodedVideoFrame(on_video_decoded_cb_);
  87 }
  88
  89 void  CastReceiverSessionDelegate::StopVideo() {
  90   frame_callback_ = content::VideoCaptureDeliverFrameCB();
  91 }
  92
  93 void CastReceiverSessionDelegate::OnDecodedVideoFrame(
  94     const scoped_refptr<media::VideoFrame>& video_frame,
  95     const base::TimeTicks& playout_time,
  96     bool is_continous) {
  97   if (frame_callback_.is_null())
  98     return;
  99   frame_callback_.Run(video_frame, format_, playout_time);
 100   cast_receiver_->RequestDecodedVideoFrame(on_video_decoded_cb_);
 101 }