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 { | |
15 | |
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 | |
18 // those frames get dropped. | |
19 static const int kMaxBufferCount = 3; | |
20 } | |
21 | |
22 namespace video_capture { | 14 namespace video_capture { |
23 | 15 |
24 DeviceMediaToMojoAdapter::DeviceMediaToMojoAdapter( | 16 DeviceMediaToMojoAdapter::DeviceMediaToMojoAdapter( |
25 std::unique_ptr<media::VideoCaptureDevice> device, | 17 std::unique_ptr<media::VideoCaptureDevice> device, |
26 const media::VideoCaptureJpegDecoderFactoryCB& | 18 const media::VideoCaptureJpegDecoderFactoryCB& |
27 jpeg_decoder_factory_callback) | 19 jpeg_decoder_factory_callback) |
28 : device_(std::move(device)), | 20 : device_(std::move(device)), |
29 jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback), | 21 jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback), |
30 device_running_(false) {} | 22 device_running_(false) {} |
31 | 23 |
32 DeviceMediaToMojoAdapter::~DeviceMediaToMojoAdapter() { | 24 DeviceMediaToMojoAdapter::~DeviceMediaToMojoAdapter() { |
33 if (device_running_) | 25 Stop(); |
34 device_->StopAndDeAllocate(); | |
35 } | 26 } |
36 | 27 |
37 void DeviceMediaToMojoAdapter::Start( | 28 void DeviceMediaToMojoAdapter::Start( |
38 const media::VideoCaptureParams& requested_settings, | 29 const media::VideoCaptureParams& requested_settings, |
39 mojom::ReceiverPtr receiver) { | 30 mojom::ReceiverPtr receiver) { |
40 receiver.set_connection_error_handler( | 31 receiver.set_connection_error_handler( |
41 base::Bind(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose, | 32 base::Bind(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose, |
42 base::Unretained(this))); | 33 base::Unretained(this))); |
43 | 34 |
44 auto media_receiver = | 35 auto media_receiver = |
45 base::MakeUnique<ReceiverMojoToMediaAdapter>(std::move(receiver)); | 36 base::MakeUnique<ReceiverMojoToMediaAdapter>(std::move(receiver)); |
46 | 37 |
47 // Create a dedicated buffer pool for the device usage session. | 38 // Create a dedicated buffer pool for the device usage session. |
| 39 const int kMaxBufferCount = 2; |
48 auto buffer_tracker_factory = | 40 auto buffer_tracker_factory = |
49 base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(); | 41 base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(); |
50 scoped_refptr<media::VideoCaptureBufferPool> buffer_pool( | 42 scoped_refptr<media::VideoCaptureBufferPool> buffer_pool( |
51 new media::VideoCaptureBufferPoolImpl(std::move(buffer_tracker_factory), | 43 new media::VideoCaptureBufferPoolImpl(std::move(buffer_tracker_factory), |
52 max_buffer_pool_buffer_count())); | 44 kMaxBufferCount)); |
53 | 45 |
54 auto device_client = base::MakeUnique<media::VideoCaptureDeviceClient>( | 46 auto device_client = base::MakeUnique<media::VideoCaptureDeviceClient>( |
55 std::move(media_receiver), buffer_pool, jpeg_decoder_factory_callback_); | 47 std::move(media_receiver), buffer_pool, jpeg_decoder_factory_callback_); |
56 | 48 |
57 device_->AllocateAndStart(requested_settings, std::move(device_client)); | 49 device_->AllocateAndStart(requested_settings, std::move(device_client)); |
58 device_running_ = true; | 50 device_running_ = true; |
59 } | 51 } |
60 | 52 |
61 void DeviceMediaToMojoAdapter::OnReceiverReportingUtilization( | |
62 int32_t frame_feedback_id, | |
63 double utilization) { | |
64 device_->OnUtilizationReport(frame_feedback_id, utilization); | |
65 } | |
66 | |
67 void DeviceMediaToMojoAdapter::Stop() { | 53 void DeviceMediaToMojoAdapter::Stop() { |
68 if (device_running_ == false) | 54 if (device_running_ == false) |
69 return; | 55 return; |
| 56 device_->StopAndDeAllocate(); |
70 device_running_ = false; | 57 device_running_ = false; |
71 device_->StopAndDeAllocate(); | |
72 } | 58 } |
73 | 59 |
74 void DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose() { | 60 void DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose() { |
75 Stop(); | 61 Stop(); |
76 } | 62 } |
77 | 63 |
78 // static | |
79 int DeviceMediaToMojoAdapter::max_buffer_pool_buffer_count() { | |
80 return kMaxBufferCount; | |
81 } | |
82 | |
83 } // namespace video_capture | 64 } // namespace video_capture |
OLD | NEW |