OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/video_capture_message_filter.h" | 5 #include "content/renderer/media/video_capture_message_filter.h" |
6 | 6 |
| 7 #include "content/common/media/encoded_video_capture_messages.h" |
7 #include "content/common/media/video_capture_messages.h" | 8 #include "content/common/media/video_capture_messages.h" |
8 #include "content/common/view_messages.h" | 9 #include "content/common/view_messages.h" |
9 | 10 |
10 namespace content { | 11 namespace content { |
11 | 12 |
12 VideoCaptureMessageFilter::VideoCaptureMessageFilter() | 13 VideoCaptureMessageFilter::VideoCaptureMessageFilter() |
13 : last_device_id_(0), | 14 : last_device_id_(0), |
14 channel_(NULL) { | 15 channel_(NULL) { |
15 } | 16 } |
16 | 17 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 return channel_->Send(message); | 55 return channel_->Send(message); |
55 } | 56 } |
56 | 57 |
57 bool VideoCaptureMessageFilter::OnMessageReceived(const IPC::Message& message) { | 58 bool VideoCaptureMessageFilter::OnMessageReceived(const IPC::Message& message) { |
58 bool handled = true; | 59 bool handled = true; |
59 IPC_BEGIN_MESSAGE_MAP(VideoCaptureMessageFilter, message) | 60 IPC_BEGIN_MESSAGE_MAP(VideoCaptureMessageFilter, message) |
60 IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferReceived) | 61 IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferReceived) |
61 IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnDeviceStateChanged) | 62 IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnDeviceStateChanged) |
62 IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnBufferCreated) | 63 IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnBufferCreated) |
63 IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceInfo, OnDeviceInfoReceived) | 64 IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceInfo, OnDeviceInfoReceived) |
64 IPC_MESSAGE_UNHANDLED(handled = false) | 65 IPC_MESSAGE_HANDLER(EncodedVideoCaptureMsg_CapabilitiesAvailable, |
| 66 OnCapabilitiesAvailable) |
| 67 IPC_MESSAGE_HANDLER(EncodedVideoCaptureMsg_BitstreamOpened, |
| 68 OnBitstreamOpened) |
| 69 IPC_MESSAGE_HANDLER(EncodedVideoCaptureMsg_BitstreamClosed, |
| 70 OnBitstreamClosed) |
| 71 IPC_MESSAGE_HANDLER(EncodedVideoCaptureMsg_BitstreamConfigChanged, |
| 72 OnBitstreamConfigChanged) |
| 73 IPC_MESSAGE_HANDLER(EncodedVideoCaptureMsg_BitstreamReady, |
| 74 OnBitstreamReady); |
| 75 IPC_MESSAGE_UNHANDLED(handled = false) |
65 IPC_END_MESSAGE_MAP() | 76 IPC_END_MESSAGE_MAP() |
66 return handled; | 77 return handled; |
67 } | 78 } |
68 | 79 |
69 void VideoCaptureMessageFilter::OnFilterAdded(IPC::Channel* channel) { | 80 void VideoCaptureMessageFilter::OnFilterAdded(IPC::Channel* channel) { |
70 DVLOG(1) << "VideoCaptureMessageFilter::OnFilterAdded()"; | 81 DVLOG(1) << "VideoCaptureMessageFilter::OnFilterAdded()"; |
71 // Captures the message loop proxy for IPC. | 82 // Captures the message loop proxy for IPC. |
72 message_loop_proxy_ = base::MessageLoopProxy::current(); | 83 message_loop_proxy_ = base::MessageLoopProxy::current(); |
73 channel_ = channel; | 84 channel_ = channel; |
74 | 85 |
75 for (Delegates::iterator it = pending_delegates_.begin(); | 86 for (Delegates::iterator it = pending_delegates_.begin(); |
76 it != pending_delegates_.end(); it++) { | 87 it != pending_delegates_.end(); it++) { |
77 it->second->OnDelegateAdded(it->first); | 88 it->second->OnDelegateAdded(it->first); |
78 delegates_[it->first] = it->second; | 89 delegates_[it->first] = it->second; |
79 } | 90 } |
80 pending_delegates_.clear(); | 91 pending_delegates_.clear(); |
81 } | 92 } |
82 | 93 |
83 void VideoCaptureMessageFilter::OnFilterRemoved() { | 94 void VideoCaptureMessageFilter::OnFilterRemoved() { |
84 channel_ = NULL; | 95 channel_ = NULL; |
85 } | 96 } |
86 | 97 |
87 void VideoCaptureMessageFilter::OnChannelClosing() { | 98 void VideoCaptureMessageFilter::OnChannelClosing() { |
88 channel_ = NULL; | 99 channel_ = NULL; |
89 } | 100 } |
90 | 101 |
91 VideoCaptureMessageFilter::~VideoCaptureMessageFilter() {} | 102 VideoCaptureMessageFilter::~VideoCaptureMessageFilter() {} |
92 | 103 |
| 104 VideoCaptureMessageFilter::Delegate* VideoCaptureMessageFilter::find_delegate( |
| 105 int device_id) const { |
| 106 Delegates::const_iterator i = delegates_.find(device_id); |
| 107 return i != delegates_.end() ? i->second : NULL; |
| 108 } |
| 109 |
93 void VideoCaptureMessageFilter::OnBufferCreated( | 110 void VideoCaptureMessageFilter::OnBufferCreated( |
94 int device_id, | 111 int device_id, |
95 base::SharedMemoryHandle handle, | 112 base::SharedMemoryHandle handle, |
96 int length, | 113 int length, |
97 int buffer_id) { | 114 int buffer_id) { |
98 Delegate* delegate = NULL; | 115 Delegate* delegate = find_delegate(device_id); |
99 if (delegates_.find(device_id) != delegates_.end()) | |
100 delegate = delegates_.find(device_id)->second; | |
101 | |
102 if (!delegate) { | 116 if (!delegate) { |
103 DLOG(WARNING) << "OnBufferCreated: Got video frame buffer for a " | 117 DLOG(WARNING) << "OnBufferCreated: Got video frame buffer for a " |
104 "non-existent or removed video capture."; | 118 "non-existent or removed video capture."; |
105 | 119 |
106 // Send the buffer back to Host in case it's waiting for all buffers | 120 // Send the buffer back to Host in case it's waiting for all buffers |
107 // to be returned. | 121 // to be returned. |
108 base::SharedMemory::CloseHandle(handle); | 122 base::SharedMemory::CloseHandle(handle); |
109 Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id)); | 123 Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id)); |
110 return; | 124 return; |
111 } | 125 } |
112 | 126 |
113 delegate->OnBufferCreated(handle, length, buffer_id); | 127 delegate->OnBufferCreated(handle, length, buffer_id); |
114 } | 128 } |
115 | 129 |
116 void VideoCaptureMessageFilter::OnBufferReceived( | 130 void VideoCaptureMessageFilter::OnBufferReceived( |
117 int device_id, | 131 int device_id, |
118 int buffer_id, | 132 int buffer_id, |
119 base::Time timestamp) { | 133 base::Time timestamp) { |
120 Delegate* delegate = NULL; | 134 Delegate* delegate = find_delegate(device_id); |
121 if (delegates_.find(device_id) != delegates_.end()) | |
122 delegate = delegates_.find(device_id)->second; | |
123 | |
124 if (!delegate) { | 135 if (!delegate) { |
125 DLOG(WARNING) << "OnBufferReceived: Got video frame buffer for a " | 136 DLOG(WARNING) << "OnBufferReceived: Got video frame buffer for a " |
126 "non-existent or removed video capture."; | 137 "non-existent or removed video capture."; |
127 | 138 |
128 // Send the buffer back to Host in case it's waiting for all buffers | 139 // Send the buffer back to Host in case it's waiting for all buffers |
129 // to be returned. | 140 // to be returned. |
130 Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id)); | 141 Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id)); |
131 return; | 142 return; |
132 } | 143 } |
133 | 144 |
134 delegate->OnBufferReceived(buffer_id, timestamp); | 145 delegate->OnBufferReceived(buffer_id, timestamp); |
135 } | 146 } |
136 | 147 |
137 void VideoCaptureMessageFilter::OnDeviceStateChanged( | 148 void VideoCaptureMessageFilter::OnDeviceStateChanged( |
138 int device_id, | 149 int device_id, |
139 VideoCaptureState state) { | 150 VideoCaptureState state) { |
140 Delegate* delegate = NULL; | 151 Delegate* delegate = find_delegate(device_id); |
141 if (delegates_.find(device_id) != delegates_.end()) | |
142 delegate = delegates_.find(device_id)->second; | |
143 if (!delegate) { | 152 if (!delegate) { |
144 DLOG(WARNING) << "OnDeviceStateChanged: Got video capture event for a " | 153 DLOG(WARNING) << "OnDeviceStateChanged: Got video capture event for a " |
145 "non-existent or removed video capture."; | 154 "non-existent or removed video capture."; |
146 return; | 155 return; |
147 } | 156 } |
148 delegate->OnStateChanged(state); | 157 delegate->OnStateChanged(state); |
149 } | 158 } |
150 | 159 |
151 void VideoCaptureMessageFilter::OnDeviceInfoReceived( | 160 void VideoCaptureMessageFilter::OnDeviceInfoReceived( |
152 int device_id, | 161 int device_id, |
153 const media::VideoCaptureParams& params) { | 162 const media::VideoCaptureParams& params) { |
154 Delegate* delegate = NULL; | 163 Delegate* delegate = find_delegate(device_id); |
155 if (delegates_.find(device_id) != delegates_.end()) | |
156 delegate = delegates_.find(device_id)->second; | |
157 if (!delegate) { | 164 if (!delegate) { |
158 DLOG(WARNING) << "OnDeviceInfoReceived: Got video capture event for a " | 165 DLOG(WARNING) << "OnDeviceInfoReceived: Got video capture event for a " |
159 "non-existent or removed video capture."; | 166 "non-existent or removed video capture."; |
160 return; | 167 return; |
161 } | 168 } |
162 delegate->OnDeviceInfoReceived(params); | 169 delegate->OnDeviceInfoReceived(params); |
163 } | 170 } |
164 | 171 |
| 172 void VideoCaptureMessageFilter::OnCapabilitiesAvailable( |
| 173 int device_id, |
| 174 media::VideoEncodingCapabilities capabilities) { |
| 175 Delegate* delegate = find_delegate(device_id); |
| 176 if (!delegate) { |
| 177 DLOG(WARNING) << "OnCapabilitiesAvailable: Got video capture event for a " |
| 178 "non-existent or removed video capture."; |
| 179 return; |
| 180 } |
| 181 delegate->OnEncodingCapabilitiesAvailable(capabilities); |
| 182 } |
| 183 |
| 184 void VideoCaptureMessageFilter::OnBitstreamOpened( |
| 185 int device_id, |
| 186 media::VideoEncodingParameters params, |
| 187 std::vector<base::SharedMemoryHandle> buffers, |
| 188 uint32 buffer_size) { |
| 189 Delegate* delegate = find_delegate(device_id); |
| 190 if (!delegate) { |
| 191 DLOG(WARNING) << "OnBitstreamOpened: Got video capture event for a " |
| 192 "non-existent or removed video capture."; |
| 193 return; |
| 194 } |
| 195 delegate->OnEncodedBitstreamOpened(params, buffers, buffer_size); |
| 196 } |
| 197 |
| 198 void VideoCaptureMessageFilter::OnBitstreamClosed(int device_id) { |
| 199 Delegate* delegate = find_delegate(device_id); |
| 200 if (!delegate) { |
| 201 DLOG(WARNING) << "OnBitstreamClosed: Got video capture event for a " |
| 202 "non-existent or removed video capture."; |
| 203 return; |
| 204 } |
| 205 delegate->OnEncodedBitstreamClosed(); |
| 206 } |
| 207 |
| 208 void VideoCaptureMessageFilter::OnBitstreamConfigChanged( |
| 209 int device_id, |
| 210 media::RuntimeVideoEncodingParameters params) { |
| 211 Delegate* delegate = find_delegate(device_id); |
| 212 if (!delegate) { |
| 213 DLOG(WARNING) << "OnBitstreamConfigChanged: Got video capture event for a " |
| 214 "non-existent or removed video capture."; |
| 215 return; |
| 216 } |
| 217 delegate->OnEncodingConfigChanged(params); |
| 218 } |
| 219 |
| 220 void VideoCaptureMessageFilter::OnBitstreamReady( |
| 221 int device_id, int buffer_id, uint32 size, |
| 222 media::BufferEncodingMetadata metadata) { |
| 223 Delegate* delegate = find_delegate(device_id); |
| 224 if (!delegate) { |
| 225 DLOG(WARNING) << "OnBitstreamReady: Got video capture event for a " |
| 226 "non-existent or removed video capture."; |
| 227 return; |
| 228 } |
| 229 delegate->OnEncodedBufferReady(buffer_id, size, metadata); |
| 230 } |
| 231 |
165 } // namespace content | 232 } // namespace content |
OLD | NEW |