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
17namespace {
18
19void 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
27void 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
43CastSession::CastSession()
44    : delegate_(new CastSessionDelegate()),
45      io_message_loop_proxy_(
46          content::RenderThread::Get()->GetIOMessageLoopProxy()) {}
47
48CastSession::~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
53void 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
70void 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
91void 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
102void 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
111void 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
123void 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