Home | History | Annotate | Download | only in media 
      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 "chrome/renderer/media/cast_session.h"
      6 
      7 #include "base/message_loop/message_loop_proxy.h"
      8 #include "chrome/renderer/media/cast_session_delegate.h"
      9 #include "content/public/renderer/render_thread.h"
     10 #include "content/public/renderer/video_encode_accelerator.h"
     11 #include "media/base/bind_to_current_loop.h"
     12 #include "media/base/video_frame.h"
     13 #include "media/cast/cast_config.h"
     14 #include "media/cast/cast_sender.h"
     15 #include "media/cast/logging/logging_defines.h"
     16 
     17 namespace {
     18 
     19 void CreateVideoEncodeAccelerator(
     20     const media::cast::ReceiveVideoEncodeAcceleratorCallback& callback) {
     21   DCHECK(content::RenderThread::Get());
     22 
     23   // Delegate the call to content API on the render thread.
     24   content::CreateVideoEncodeAccelerator(callback);
     25 }
     26 
     27 void CreateVideoEncodeMemory(
     28     size_t size,
     29     const media::cast::ReceiveVideoEncodeMemoryCallback& callback) {
     30   DCHECK(content::RenderThread::Get());
     31 
     32   scoped_ptr<base::SharedMemory> shm =
     33       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(size);
     34   DCHECK(shm) << "Failed to allocate shared memory";
     35   if (!shm->Map(size)) {
     36     NOTREACHED() << "Map failed";
     37   }
     38   callback.Run(shm.Pass());
     39 }
     40 
     41 }  // namespace
     42 
     43 CastSession::CastSession()
     44     : delegate_(new CastSessionDelegate()),
     45       io_message_loop_proxy_(
     46           content::RenderThread::Get()->GetIOMessageLoopProxy()) {}
     47 
     48 CastSession::~CastSession() {
     49   // We should always be able to delete the object on the IO thread.
     50   CHECK(io_message_loop_proxy_->DeleteSoon(FROM_HERE, delegate_.release()));
     51 }
     52 
     53 void CastSession::StartAudio(const media::cast::AudioSenderConfig& config,
     54                              const AudioFrameInputAvailableCallback& callback,
     55                              const ErrorCallback& error_callback) {
     56   DCHECK(content::RenderThread::Get()
     57              ->GetMessageLoop()
     58              ->message_loop_proxy()
     59              ->BelongsToCurrentThread());
     60 
     61   io_message_loop_proxy_->PostTask(
     62       FROM_HERE,
     63       base::Bind(&CastSessionDelegate::StartAudio,
     64                  base::Unretained(delegate_.get()),
     65                  config,
     66                  media::BindToCurrentLoop(callback),
     67                  media::BindToCurrentLoop(error_callback)));
     68 }
     69 
     70 void CastSession::StartVideo(const media::cast::VideoSenderConfig& config,
     71                              const VideoFrameInputAvailableCallback& callback,
     72                              const ErrorCallback& error_callback) {
     73   DCHECK(content::RenderThread::Get()
     74              ->GetMessageLoop()
     75              ->message_loop_proxy()
     76              ->BelongsToCurrentThread());
     77 
     78   io_message_loop_proxy_->PostTask(
     79       FROM_HERE,
     80       base::Bind(&CastSessionDelegate::StartVideo,
     81                  base::Unretained(delegate_.get()),
     82                  config,
     83                  media::BindToCurrentLoop(callback),
     84                  media::BindToCurrentLoop(error_callback),
     85                  media::BindToCurrentLoop(
     86                      base::Bind(&CreateVideoEncodeAccelerator)),
     87                  media::BindToCurrentLoop(
     88                      base::Bind(&CreateVideoEncodeMemory))));
     89 }
     90 
     91 void CastSession::StartUDP(const net::IPEndPoint& remote_endpoint,
     92                            scoped_ptr<base::DictionaryValue> options) {
     93   io_message_loop_proxy_->PostTask(
     94       FROM_HERE,
     95       base::Bind(
     96           &CastSessionDelegate::StartUDP,
     97           base::Unretained(delegate_.get()),
     98           remote_endpoint,
     99           base::Passed(&options)));
    100 }
    101 
    102 void CastSession::ToggleLogging(bool is_audio, bool enable) {
    103   io_message_loop_proxy_->PostTask(
    104       FROM_HERE,
    105       base::Bind(&CastSessionDelegate::ToggleLogging,
    106                  base::Unretained(delegate_.get()),
    107                  is_audio,
    108                  enable));
    109 }
    110 
    111 void CastSession::GetEventLogsAndReset(
    112     bool is_audio, const std::string& extra_data,
    113     const EventLogsCallback& callback) {
    114   io_message_loop_proxy_->PostTask(
    115       FROM_HERE,
    116       base::Bind(&CastSessionDelegate::GetEventLogsAndReset,
    117                  base::Unretained(delegate_.get()),
    118                  is_audio,
    119                  extra_data,
    120                  media::BindToCurrentLoop(callback)));
    121 }
    122 
    123 void CastSession::GetStatsAndReset(bool is_audio,
    124                                    const StatsCallback& callback) {
    125   io_message_loop_proxy_->PostTask(
    126       FROM_HERE,
    127       base::Bind(&CastSessionDelegate::GetStatsAndReset,
    128                  base::Unretained(delegate_.get()),
    129                  is_audio,
    130                  media::BindToCurrentLoop(callback)));
    131 }
    132