OLD | NEW |
| (Empty) |
1 // Copyright 2014 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 "components/html_viewer/media_factory.h" | |
6 | |
7 #include <stdint.h> | |
8 #include <utility> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/command_line.h" | |
12 #include "base/files/file_path.h" | |
13 #include "base/path_service.h" | |
14 #include "base/threading/thread.h" | |
15 #include "build/build_config.h" | |
16 #include "media/audio/audio_manager.h" | |
17 #include "media/audio/audio_manager_base.h" | |
18 #include "media/audio/audio_output_stream_sink.h" | |
19 #include "media/base/audio_hardware_config.h" | |
20 #include "media/base/media.h" | |
21 #include "media/base/media_log.h" | |
22 #include "media/blink/webencryptedmediaclient_impl.h" | |
23 #include "media/blink/webmediaplayer_impl.h" | |
24 #include "media/blink/webmediaplayer_params.h" | |
25 #include "media/cdm/default_cdm_factory.h" | |
26 #include "media/filters/default_media_permission.h" | |
27 #include "media/mojo/interfaces/renderer.mojom.h" | |
28 #include "media/mojo/services/mojo_cdm_factory.h" | |
29 #include "media/mojo/services/mojo_renderer_factory.h" | |
30 #include "media/renderers/default_renderer_factory.h" | |
31 #include "media/renderers/gpu_video_accelerator_factories.h" | |
32 #include "mojo/shell/public/cpp/shell.h" | |
33 #include "third_party/WebKit/public/web/WebKit.h" | |
34 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
35 #include "v8/include/v8.h" | |
36 | |
37 namespace html_viewer { | |
38 | |
39 namespace { | |
40 | |
41 // Enable mojo media Renderer in media pipeline instead of using the internal | |
42 // media::Renderer implementation. | |
43 // TODO(xhwang): Move this to media_switches.h. | |
44 const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer"; | |
45 | |
46 bool AreSecureCodecsSupported() { | |
47 // Hardware-secure codecs are not currently supported by HTML Viewer on any | |
48 // platform. | |
49 return false; | |
50 } | |
51 | |
52 } // namespace | |
53 | |
54 MediaFactory::MediaFactory( | |
55 const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner, | |
56 mojo::Shell* shell) | |
57 : | |
58 #if !defined(OS_ANDROID) | |
59 media_thread_("Media"), | |
60 audio_manager_(media::AudioManager::Create(&fake_audio_log_factory_)), | |
61 audio_hardware_config_( | |
62 audio_manager_->GetInputStreamParameters( | |
63 media::AudioManagerBase::kDefaultDeviceId), | |
64 audio_manager_->GetDefaultOutputStreamParameters()), | |
65 #endif | |
66 enable_mojo_media_renderer_(base::CommandLine::ForCurrentProcess() | |
67 ->HasSwitch(kEnableMojoMediaRenderer)), | |
68 compositor_task_runner_(compositor_task_runner), | |
69 shell_(shell) { | |
70 media::InitializeMediaLibrary(); | |
71 } | |
72 | |
73 MediaFactory::~MediaFactory() { | |
74 } | |
75 | |
76 blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer( | |
77 blink::WebLocalFrame* frame, | |
78 const blink::WebURL& url, | |
79 blink::WebMediaPlayerClient* client, | |
80 blink::WebMediaPlayerEncryptedMediaClient* encrypted_client, | |
81 blink::WebContentDecryptionModule* initial_cdm, | |
82 mojo::Shell* shell) { | |
83 #if defined(OS_ANDROID) | |
84 // TODO(xhwang): Get CreateMediaPlayer working on android. | |
85 return nullptr; | |
86 #else | |
87 scoped_refptr<media::MediaLog> media_log(new media::MediaLog()); | |
88 scoped_ptr<media::RendererFactory> media_renderer_factory; | |
89 | |
90 if (enable_mojo_media_renderer_) { | |
91 media_renderer_factory.reset( | |
92 new media::MojoRendererFactory(GetMediaServiceFactory())); | |
93 } else { | |
94 media_renderer_factory.reset( | |
95 new media::DefaultRendererFactory(media_log, | |
96 nullptr, // No GPU factory. | |
97 GetAudioHardwareConfig())); | |
98 } | |
99 | |
100 media::WebMediaPlayerParams params( | |
101 media::WebMediaPlayerParams::DeferLoadCB(), CreateAudioRendererSink(), | |
102 media_log, GetMediaThreadTaskRunner(), GetMediaThreadTaskRunner(), | |
103 compositor_task_runner_, media::WebMediaPlayerParams::Context3DCB(), | |
104 base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory, | |
105 base::Unretained(blink::mainThreadIsolate())), | |
106 GetMediaPermission(), initial_cdm); | |
107 base::WeakPtr<media::WebMediaPlayerDelegate> delegate; | |
108 | |
109 if (!url_index_.get() || url_index_->frame() != frame) { | |
110 url_index_.reset(new media::UrlIndex(frame)); | |
111 } | |
112 | |
113 return new media::WebMediaPlayerImpl( | |
114 frame, client, encrypted_client, delegate, | |
115 std::move(media_renderer_factory), GetCdmFactory(), url_index_, params); | |
116 #endif // defined(OS_ANDROID) | |
117 } | |
118 | |
119 blink::WebEncryptedMediaClient* MediaFactory::GetEncryptedMediaClient() { | |
120 if (!web_encrypted_media_client_) { | |
121 web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl( | |
122 base::Bind(&AreSecureCodecsSupported), GetCdmFactory(), | |
123 GetMediaPermission())); | |
124 } | |
125 return web_encrypted_media_client_.get(); | |
126 } | |
127 | |
128 media::interfaces::ServiceFactory* MediaFactory::GetMediaServiceFactory() { | |
129 if (!media_service_factory_) | |
130 shell_->ConnectToService("mojo:media", &media_service_factory_); | |
131 return media_service_factory_.get(); | |
132 } | |
133 | |
134 media::MediaPermission* MediaFactory::GetMediaPermission() { | |
135 // TODO(xhwang): Replace DefaultMediaPermission with something real when | |
136 // permissions are supported in html_viewer. | |
137 NOTIMPLEMENTED(); | |
138 | |
139 if (!media_permission_) | |
140 media_permission_.reset(new media::DefaultMediaPermission(true)); | |
141 return media_permission_.get(); | |
142 } | |
143 | |
144 media::CdmFactory* MediaFactory::GetCdmFactory() { | |
145 if (!cdm_factory_) { | |
146 if (enable_mojo_media_renderer_) | |
147 cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceFactory())); | |
148 else | |
149 cdm_factory_.reset(new media::DefaultCdmFactory()); | |
150 } | |
151 | |
152 return cdm_factory_.get(); | |
153 } | |
154 | |
155 #if !defined(OS_ANDROID) | |
156 const media::AudioHardwareConfig& MediaFactory::GetAudioHardwareConfig() { | |
157 return audio_hardware_config_; | |
158 } | |
159 | |
160 scoped_refptr<media::RestartableAudioRendererSink> | |
161 MediaFactory::CreateAudioRendererSink() { | |
162 // TODO(dalecurtis): Replace this with an interface to an actual mojo service; | |
163 // the AudioOutputStreamSink will not work in sandboxed processes. | |
164 return new media::AudioOutputStreamSink(); | |
165 } | |
166 | |
167 scoped_refptr<base::SingleThreadTaskRunner> | |
168 MediaFactory::GetMediaThreadTaskRunner() { | |
169 if (!media_thread_.IsRunning()) | |
170 media_thread_.Start(); | |
171 | |
172 return media_thread_.task_runner(); | |
173 } | |
174 #endif // !defined(OS_ANDROID) | |
175 | |
176 } // namespace html_viewer | |
OLD | NEW |