OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "services/video_capture/device_media_to_mojo_adapter.h" | 5 #include "services/video_capture/device_media_to_mojo_adapter.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "media/capture/video/video_capture_buffer_pool_impl.h" | 9 #include "media/capture/video/video_capture_buffer_pool_impl.h" |
10 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h" | 10 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h" |
11 #include "media/capture/video/video_capture_jpeg_decoder.h" | 11 #include "media/capture/video/video_capture_jpeg_decoder.h" |
12 #include "services/video_capture/receiver_mojo_to_media_adapter.h" | 12 #include "services/video_capture/receiver_mojo_to_media_adapter.h" |
13 | 13 |
14 namespace { | 14 namespace { |
15 | 15 |
16 // The maximum number of video frame buffers in-flight at any one time. | 16 // The maximum number of video frame buffers in-flight at any one time. |
17 // If all buffers are still in use by consumers when new frames are produced | 17 // If all buffers are still in use by consumers when new frames are produced |
18 // those frames get dropped. | 18 // those frames get dropped. |
19 static const int kMaxBufferCount = 3; | 19 static const int kMaxBufferCount = 3; |
20 } | 20 } |
21 | 21 |
22 namespace video_capture { | 22 namespace video_capture { |
23 | 23 |
24 DeviceMediaToMojoAdapter::DeviceMediaToMojoAdapter( | 24 DeviceMediaToMojoAdapter::DeviceMediaToMojoAdapter( |
| 25 std::unique_ptr<service_manager::ServiceContextRef> service_ref, |
25 std::unique_ptr<media::VideoCaptureDevice> device, | 26 std::unique_ptr<media::VideoCaptureDevice> device, |
26 const media::VideoCaptureJpegDecoderFactoryCB& | 27 const media::VideoCaptureJpegDecoderFactoryCB& |
27 jpeg_decoder_factory_callback) | 28 jpeg_decoder_factory_callback) |
28 : device_(std::move(device)), | 29 : service_ref_(std::move(service_ref)), |
| 30 device_(std::move(device)), |
29 jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback), | 31 jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback), |
30 device_running_(false) {} | 32 device_started_(false) {} |
31 | 33 |
32 DeviceMediaToMojoAdapter::~DeviceMediaToMojoAdapter() { | 34 DeviceMediaToMojoAdapter::~DeviceMediaToMojoAdapter() { |
33 if (device_running_) | 35 DCHECK(thread_checker_.CalledOnValidThread()); |
| 36 if (device_started_) |
34 device_->StopAndDeAllocate(); | 37 device_->StopAndDeAllocate(); |
35 } | 38 } |
36 | 39 |
37 void DeviceMediaToMojoAdapter::Start( | 40 void DeviceMediaToMojoAdapter::Start( |
38 const media::VideoCaptureParams& requested_settings, | 41 const media::VideoCaptureParams& requested_settings, |
39 mojom::ReceiverPtr receiver) { | 42 mojom::ReceiverPtr receiver) { |
| 43 DCHECK(thread_checker_.CalledOnValidThread()); |
40 receiver.set_connection_error_handler( | 44 receiver.set_connection_error_handler( |
41 base::Bind(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose, | 45 base::Bind(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose, |
42 base::Unretained(this))); | 46 base::Unretained(this))); |
43 | 47 |
44 auto media_receiver = | 48 auto receiver_adapter = |
45 base::MakeUnique<ReceiverMojoToMediaAdapter>(std::move(receiver)); | 49 base::MakeUnique<ReceiverMojoToMediaAdapter>(std::move(receiver)); |
| 50 // We must hold on something that allows us to unsubscribe from |
| 51 // receiver.set_connection_error_handler() when we stop the device. Otherwise, |
| 52 // we may receive a corresponding callback after having been destroyed. |
| 53 // This happens when the deletion of |receiver| is delayed (scheduled to a |
| 54 // task runner) when we release |device_|, as is the case when using |
| 55 // ReceiverOnTaskRunner. |
| 56 receiver_adapter_ptr_ = receiver_adapter.get(); |
| 57 auto media_receiver = base::MakeUnique<ReceiverOnTaskRunner>( |
| 58 std::move(receiver_adapter), base::ThreadTaskRunnerHandle::Get()); |
46 | 59 |
47 // Create a dedicated buffer pool for the device usage session. | 60 // Create a dedicated buffer pool for the device usage session. |
48 auto buffer_tracker_factory = | 61 auto buffer_tracker_factory = |
49 base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(); | 62 base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(); |
50 scoped_refptr<media::VideoCaptureBufferPool> buffer_pool( | 63 scoped_refptr<media::VideoCaptureBufferPool> buffer_pool( |
51 new media::VideoCaptureBufferPoolImpl(std::move(buffer_tracker_factory), | 64 new media::VideoCaptureBufferPoolImpl(std::move(buffer_tracker_factory), |
52 max_buffer_pool_buffer_count())); | 65 max_buffer_pool_buffer_count())); |
53 | 66 |
54 auto device_client = base::MakeUnique<media::VideoCaptureDeviceClient>( | 67 auto device_client = base::MakeUnique<media::VideoCaptureDeviceClient>( |
55 std::move(media_receiver), buffer_pool, jpeg_decoder_factory_callback_); | 68 std::move(media_receiver), buffer_pool, jpeg_decoder_factory_callback_); |
56 | 69 |
57 device_->AllocateAndStart(requested_settings, std::move(device_client)); | 70 device_->AllocateAndStart(requested_settings, std::move(device_client)); |
58 device_running_ = true; | 71 device_started_ = true; |
59 } | 72 } |
60 | 73 |
61 void DeviceMediaToMojoAdapter::OnReceiverReportingUtilization( | 74 void DeviceMediaToMojoAdapter::OnReceiverReportingUtilization( |
62 int32_t frame_feedback_id, | 75 int32_t frame_feedback_id, |
63 double utilization) { | 76 double utilization) { |
| 77 DCHECK(thread_checker_.CalledOnValidThread()); |
64 device_->OnUtilizationReport(frame_feedback_id, utilization); | 78 device_->OnUtilizationReport(frame_feedback_id, utilization); |
65 } | 79 } |
66 | 80 |
67 void DeviceMediaToMojoAdapter::Stop() { | 81 void DeviceMediaToMojoAdapter::Stop() { |
68 if (device_running_ == false) | 82 DCHECK(thread_checker_.CalledOnValidThread()); |
| 83 if (device_started_ == false) |
69 return; | 84 return; |
70 device_running_ = false; | 85 device_started_ = false; |
| 86 // Unsubscribe from connection error callbacks. |
| 87 receiver_adapter_ptr_->ResetConnectionErrorHandler(); |
| 88 receiver_adapter_ptr_ = nullptr; |
71 device_->StopAndDeAllocate(); | 89 device_->StopAndDeAllocate(); |
72 } | 90 } |
73 | 91 |
74 void DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose() { | 92 void DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose() { |
| 93 DCHECK(thread_checker_.CalledOnValidThread()); |
75 Stop(); | 94 Stop(); |
76 } | 95 } |
77 | 96 |
78 // static | 97 // static |
79 int DeviceMediaToMojoAdapter::max_buffer_pool_buffer_count() { | 98 int DeviceMediaToMojoAdapter::max_buffer_pool_buffer_count() { |
80 return kMaxBufferCount; | 99 return kMaxBufferCount; |
81 } | 100 } |
82 | 101 |
83 } // namespace video_capture | 102 } // namespace video_capture |
OLD | NEW |