OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h" | 5 #include "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/bind.h" | 12 #include "base/bind.h" |
13 #include "base/command_line.h" | |
14 #include "base/containers/hash_tables.h" | 13 #include "base/containers/hash_tables.h" |
15 #include "base/logging.h" | 14 #include "base/logging.h" |
16 #include "base/memory/ptr_util.h" | 15 #include "base/memory/ptr_util.h" |
17 #include "base/memory/shared_memory.h" | 16 #include "base/memory/shared_memory.h" |
18 #include "base/single_thread_task_runner.h" | 17 #include "base/single_thread_task_runner.h" |
19 #include "base/threading/thread_task_runner_handle.h" | 18 #include "base/threading/thread_task_runner_handle.h" |
20 #include "base/trace_event/trace_event.h" | 19 #include "base/trace_event/trace_event.h" |
21 #include "build/build_config.h" | 20 #include "build/build_config.h" |
22 #include "gpu/ipc/service/gpu_channel.h" | 21 #include "gpu/ipc/service/gpu_channel.h" |
23 #include "ipc/ipc_message_macros.h" | 22 #include "ipc/ipc_message_macros.h" |
24 #include "ipc/message_filter.h" | 23 #include "ipc/message_filter.h" |
25 #include "media/base/media_switches.h" | |
26 #include "media/filters/jpeg_parser.h" | 24 #include "media/filters/jpeg_parser.h" |
27 #include "media/gpu/fake_jpeg_decode_accelerator.h" | |
28 #include "media/gpu/ipc/common/media_messages.h" | 25 #include "media/gpu/ipc/common/media_messages.h" |
29 #include "ui/gfx/geometry/size.h" | 26 #include "ui/gfx/geometry/size.h" |
30 | 27 |
31 #if defined(OS_CHROMEOS) | 28 #if defined(OS_CHROMEOS) |
32 #if defined(ARCH_CPU_X86_FAMILY) | 29 #if defined(ARCH_CPU_X86_FAMILY) |
33 #include "media/gpu/vaapi_jpeg_decode_accelerator.h" | 30 #include "media/gpu/vaapi_jpeg_decode_accelerator.h" |
34 #endif | 31 #endif |
35 #if defined(USE_V4L2_CODEC) | 32 #if defined(USE_V4L2_CODEC) |
36 #include "media/gpu/v4l2_device.h" | 33 #include "media/gpu/v4l2_device.h" |
37 #include "media/gpu/v4l2_jpeg_decode_accelerator.h" | 34 #include "media/gpu/v4l2_jpeg_decode_accelerator.h" |
(...skipping 17 matching lines...) Expand all Loading... |
55 std::unique_ptr<media::JpegDecodeAccelerator> CreateVaapiJDA( | 52 std::unique_ptr<media::JpegDecodeAccelerator> CreateVaapiJDA( |
56 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) { | 53 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) { |
57 std::unique_ptr<media::JpegDecodeAccelerator> decoder; | 54 std::unique_ptr<media::JpegDecodeAccelerator> decoder; |
58 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) | 55 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) |
59 decoder.reset( | 56 decoder.reset( |
60 new media::VaapiJpegDecodeAccelerator(std::move(io_task_runner))); | 57 new media::VaapiJpegDecodeAccelerator(std::move(io_task_runner))); |
61 #endif | 58 #endif |
62 return decoder; | 59 return decoder; |
63 } | 60 } |
64 | 61 |
65 std::unique_ptr<media::JpegDecodeAccelerator> CreateFakeJDA( | |
66 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) { | |
67 return base::MakeUnique<media::FakeJpegDecodeAccelerator>( | |
68 std::move(io_task_runner)); | |
69 } | |
70 | |
71 void DecodeFinished(std::unique_ptr<base::SharedMemory> shm) { | 62 void DecodeFinished(std::unique_ptr<base::SharedMemory> shm) { |
72 // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this | 63 // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this |
73 // function is to just keep reference of |shm| to make sure it lives until | 64 // function is to just keep reference of |shm| to make sure it lives until |
74 // decode finishes. | 65 // decode finishes. |
75 } | 66 } |
76 | 67 |
77 bool VerifyDecodeParams(const AcceleratedJpegDecoderMsg_Decode_Params& params) { | 68 bool VerifyDecodeParams(const AcceleratedJpegDecoderMsg_Decode_Params& params) { |
78 const int kJpegMaxDimension = UINT16_MAX; | 69 const int kJpegMaxDimension = UINT16_MAX; |
79 if (params.coded_size.IsEmpty() || | 70 if (params.coded_size.IsEmpty() || |
80 params.coded_size.width() > kJpegMaxDimension || | 71 params.coded_size.width() > kJpegMaxDimension || |
(...skipping 15 matching lines...) Expand all Loading... |
96 return false; | 87 return false; |
97 } | 88 } |
98 | 89 |
99 return true; | 90 return true; |
100 } | 91 } |
101 | 92 |
102 } // namespace | 93 } // namespace |
103 | 94 |
104 namespace media { | 95 namespace media { |
105 | 96 |
106 class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client { | 97 class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client, |
| 98 public base::NonThreadSafe { |
107 public: | 99 public: |
108 Client(base::WeakPtr<GpuJpegDecodeAccelerator> owner, | 100 Client(GpuJpegDecodeAccelerator* owner, int32_t route_id) |
109 int32_t route_id, | 101 : owner_(owner->AsWeakPtr()), route_id_(route_id) {} |
110 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) | |
111 : owner_(std::move(owner)), | |
112 route_id_(route_id), | |
113 io_task_runner_(std::move(io_task_runner)) { | |
114 DCHECK(thread_checker_.CalledOnValidThread()); | |
115 } | |
116 | 102 |
117 ~Client() override { DCHECK(thread_checker_.CalledOnValidThread()); } | 103 ~Client() override { DCHECK(CalledOnValidThread()); } |
118 | 104 |
119 // JpegDecodeAccelerator::Client implementation. | 105 // JpegDecodeAccelerator::Client implementation. |
120 void VideoFrameReady(int32_t bitstream_buffer_id) override { | 106 void VideoFrameReady(int32_t bitstream_buffer_id) override { |
121 DCHECK(thread_checker_.CalledOnValidThread()); | 107 DCHECK(CalledOnValidThread()); |
122 if (owner_) | 108 if (owner_) |
123 owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, | 109 owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, |
124 JpegDecodeAccelerator::NO_ERRORS); | 110 JpegDecodeAccelerator::NO_ERRORS); |
125 } | 111 } |
126 | 112 |
127 void NotifyError(int32_t bitstream_buffer_id, | 113 void NotifyError(int32_t bitstream_buffer_id, |
128 JpegDecodeAccelerator::Error error) override { | 114 JpegDecodeAccelerator::Error error) override { |
129 DCHECK(thread_checker_.CalledOnValidThread()); | 115 DCHECK(CalledOnValidThread()); |
130 if (owner_) | 116 if (owner_) |
131 owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, error); | 117 owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, error); |
132 } | 118 } |
133 | 119 |
134 void Decode(const BitstreamBuffer& bitstream_buffer, | 120 void Decode(const BitstreamBuffer& bitstream_buffer, |
135 const scoped_refptr<VideoFrame>& video_frame) { | 121 const scoped_refptr<VideoFrame>& video_frame) { |
136 DCHECK(io_task_runner_->BelongsToCurrentThread()); | 122 DCHECK(CalledOnValidThread()); |
137 DCHECK(accelerator_); | 123 DCHECK(accelerator_); |
138 accelerator_->Decode(bitstream_buffer, video_frame); | 124 accelerator_->Decode(bitstream_buffer, video_frame); |
139 } | 125 } |
140 | 126 |
141 void set_accelerator(std::unique_ptr<JpegDecodeAccelerator> accelerator) { | 127 void set_accelerator(std::unique_ptr<JpegDecodeAccelerator> accelerator) { |
142 DCHECK(thread_checker_.CalledOnValidThread()); | 128 DCHECK(CalledOnValidThread()); |
143 accelerator_ = std::move(accelerator); | 129 accelerator_ = std::move(accelerator); |
144 } | 130 } |
145 | 131 |
146 private: | 132 private: |
147 base::ThreadChecker thread_checker_; | |
148 base::WeakPtr<GpuJpegDecodeAccelerator> owner_; | 133 base::WeakPtr<GpuJpegDecodeAccelerator> owner_; |
149 const int32_t route_id_; | 134 int32_t route_id_; |
150 const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; | |
151 std::unique_ptr<JpegDecodeAccelerator> accelerator_; | 135 std::unique_ptr<JpegDecodeAccelerator> accelerator_; |
152 }; | 136 }; |
153 | 137 |
154 // Create, destroy, and RemoveClient run on child thread. All other methods run | 138 // Create, destroy, and RemoveClient run on child thread. All other methods run |
155 // on IO thread. | 139 // on IO thread. |
156 // TODO(chfremer): Migrate this to Mojo. See https://crbug.com/699255 | |
157 class GpuJpegDecodeAccelerator::MessageFilter : public IPC::MessageFilter { | 140 class GpuJpegDecodeAccelerator::MessageFilter : public IPC::MessageFilter { |
158 public: | 141 public: |
159 explicit MessageFilter(GpuJpegDecodeAccelerator* owner) | 142 explicit MessageFilter(GpuJpegDecodeAccelerator* owner) |
160 : owner_(owner->AsWeakPtr()), | 143 : owner_(owner->AsWeakPtr()), |
161 child_task_runner_(owner_->child_task_runner_), | 144 child_task_runner_(owner_->child_task_runner_), |
162 io_task_runner_(owner_->io_task_runner_) {} | 145 io_task_runner_(owner_->io_task_runner_) {} |
163 | 146 |
164 void OnChannelError() override { sender_ = nullptr; } | 147 void OnChannelError() override { sender_ = nullptr; } |
165 | 148 |
166 void OnChannelClosing() override { sender_ = nullptr; } | 149 void OnChannelClosing() override { sender_ = nullptr; } |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
341 return true; | 324 return true; |
342 } | 325 } |
343 return false; | 326 return false; |
344 } | 327 } |
345 | 328 |
346 // static | 329 // static |
347 std::vector<GpuJpegDecodeAcceleratorFactoryProvider::CreateAcceleratorCB> | 330 std::vector<GpuJpegDecodeAcceleratorFactoryProvider::CreateAcceleratorCB> |
348 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories() { | 331 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories() { |
349 // This list is ordered by priority of use. | 332 // This list is ordered by priority of use. |
350 std::vector<CreateAcceleratorCB> result; | 333 std::vector<CreateAcceleratorCB> result; |
351 if (base::CommandLine::ForCurrentProcess()->HasSwitch( | 334 result.push_back(base::Bind(&CreateV4L2JDA)); |
352 switches::kUseFakeJpegDecodeAccelerator)) { | 335 result.push_back(base::Bind(&CreateVaapiJDA)); |
353 result.push_back(base::Bind(&CreateFakeJDA)); | |
354 } else { | |
355 result.push_back(base::Bind(&CreateV4L2JDA)); | |
356 result.push_back(base::Bind(&CreateVaapiJDA)); | |
357 } | |
358 return result; | 336 return result; |
359 } | 337 } |
360 | 338 |
361 GpuJpegDecodeAccelerator::GpuJpegDecodeAccelerator( | 339 GpuJpegDecodeAccelerator::GpuJpegDecodeAccelerator( |
362 gpu::FilteredSender* channel, | 340 gpu::FilteredSender* channel, |
363 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) | 341 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) |
364 : GpuJpegDecodeAccelerator( | 342 : GpuJpegDecodeAccelerator( |
365 channel, | 343 channel, |
366 std::move(io_task_runner), | 344 std::move(io_task_runner), |
367 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories()) {} | 345 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories()) {} |
(...skipping 16 matching lines...) Expand all Loading... |
384 } | 362 } |
385 } | 363 } |
386 | 364 |
387 void GpuJpegDecodeAccelerator::AddClient(int32_t route_id, | 365 void GpuJpegDecodeAccelerator::AddClient(int32_t route_id, |
388 base::Callback<void(bool)> response) { | 366 base::Callback<void(bool)> response) { |
389 DCHECK(CalledOnValidThread()); | 367 DCHECK(CalledOnValidThread()); |
390 | 368 |
391 // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize | 369 // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize |
392 // needs to be updated. | 370 // needs to be updated. |
393 | 371 |
394 std::unique_ptr<Client> client( | 372 std::unique_ptr<Client> client(new Client(this, route_id)); |
395 new Client(AsWeakPtr(), route_id, io_task_runner_)); | |
396 std::unique_ptr<JpegDecodeAccelerator> accelerator; | 373 std::unique_ptr<JpegDecodeAccelerator> accelerator; |
397 for (const auto& create_jda_function : accelerator_factory_functions_) { | 374 for (const auto& create_jda_function : accelerator_factory_functions_) { |
398 std::unique_ptr<JpegDecodeAccelerator> tmp_accelerator = | 375 std::unique_ptr<JpegDecodeAccelerator> tmp_accelerator = |
399 create_jda_function.Run(io_task_runner_); | 376 create_jda_function.Run(io_task_runner_); |
400 if (tmp_accelerator && tmp_accelerator->Initialize(client.get())) { | 377 if (tmp_accelerator && tmp_accelerator->Initialize(client.get())) { |
401 accelerator = std::move(tmp_accelerator); | 378 accelerator = std::move(tmp_accelerator); |
402 break; | 379 break; |
403 } | 380 } |
404 } | 381 } |
405 | 382 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
446 filter_ = nullptr; | 423 filter_ = nullptr; |
447 } | 424 } |
448 } | 425 } |
449 | 426 |
450 bool GpuJpegDecodeAccelerator::Send(IPC::Message* message) { | 427 bool GpuJpegDecodeAccelerator::Send(IPC::Message* message) { |
451 DCHECK(CalledOnValidThread()); | 428 DCHECK(CalledOnValidThread()); |
452 return channel_->Send(message); | 429 return channel_->Send(message); |
453 } | 430 } |
454 | 431 |
455 } // namespace media | 432 } // namespace media |
OLD | NEW |