1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/pepper/pepper_platform_camera_device.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "content/renderer/media/video_capture_impl_manager.h"
#include "content/renderer/pepper/gfx_conversion.h"
#include "content/renderer/pepper/pepper_camera_device_host.h"
#include "content/renderer/pepper/pepper_media_device_manager.h"
#include "content/renderer/render_frame_impl.h"
#include "content/renderer/render_thread_impl.h"
#include "media/base/bind_to_current_loop.h"
namespace content {
PepperPlatformCameraDevice::PepperPlatformCameraDevice(
int render_frame_id,
const std::string& device_id,
PepperCameraDeviceHost* handler)
: render_frame_id_(render_frame_id),
device_id_(device_id),
session_id_(0),
handler_(handler),
pending_open_device_(false),
pending_open_device_id_(-1),
weak_factory_(this) {
// We need to open the device and obtain the label and session ID before
// initializing.
PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
if (device_manager) {
pending_open_device_id_ = device_manager->OpenDevice(
PP_DEVICETYPE_DEV_VIDEOCAPTURE, device_id, handler->pp_instance(),
base::Bind(&PepperPlatformCameraDevice::OnDeviceOpened,
weak_factory_.GetWeakPtr()));
pending_open_device_ = true;
}
}
void PepperPlatformCameraDevice::GetSupportedVideoCaptureFormats() {
DCHECK(thread_checker_.CalledOnValidThread());
VideoCaptureImplManager* manager =
RenderThreadImpl::current()->video_capture_impl_manager();
manager->GetDeviceSupportedFormats(
session_id_,
media::BindToCurrentLoop(base::Bind(
&PepperPlatformCameraDevice::OnDeviceSupportedFormatsEnumerated,
weak_factory_.GetWeakPtr())));
}
void PepperPlatformCameraDevice::DetachEventHandler() {
DCHECK(thread_checker_.CalledOnValidThread());
handler_ = nullptr;
if (!release_device_cb_.is_null()) {
base::ResetAndReturn(&release_device_cb_).Run();
}
if (!label_.empty()) {
PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
if (device_manager)
device_manager->CloseDevice(label_);
label_.clear();
}
if (pending_open_device_) {
PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
if (device_manager)
device_manager->CancelOpenDevice(pending_open_device_id_);
pending_open_device_ = false;
pending_open_device_id_ = -1;
}
}
PepperPlatformCameraDevice::~PepperPlatformCameraDevice() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(release_device_cb_.is_null());
DCHECK(label_.empty());
DCHECK(!pending_open_device_);
}
void PepperPlatformCameraDevice::OnDeviceOpened(int request_id,
bool succeeded,
const std::string& label) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(handler_);
pending_open_device_ = false;
pending_open_device_id_ = -1;
PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
succeeded = succeeded && device_manager;
if (succeeded) {
label_ = label;
session_id_ =
device_manager->GetSessionID(PP_DEVICETYPE_DEV_VIDEOCAPTURE, label);
VideoCaptureImplManager* manager =
RenderThreadImpl::current()->video_capture_impl_manager();
release_device_cb_ = manager->UseDevice(session_id_);
}
handler_->OnInitialized(succeeded);
}
void PepperPlatformCameraDevice::OnDeviceSupportedFormatsEnumerated(
const media::VideoCaptureFormats& formats) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(handler_);
std::vector<PP_VideoCaptureFormat> output_formats;
for (const auto& format : formats) {
PP_VideoCaptureFormat output_format;
output_format.frame_size = PP_FromGfxSize(format.frame_size);
output_format.frame_rate = format.frame_rate;
output_formats.push_back(output_format);
}
handler_->OnVideoCaptureFormatsEnumerated(output_formats);
}
PepperMediaDeviceManager* PepperPlatformCameraDevice::GetMediaDeviceManager() {
RenderFrameImpl* const render_frame =
RenderFrameImpl::FromRoutingID(render_frame_id_);
return render_frame
? PepperMediaDeviceManager::GetForRenderFrame(render_frame).get()
: nullptr;
}
} // namespace content
|
