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 "remoting/client/audio_decode_scheduler.h" | 5 #include "remoting/client/audio_decode_scheduler.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/single_thread_task_runner.h" | 12 #include "base/single_thread_task_runner.h" |
13 #include "remoting/client/audio_player.h" | 13 #include "remoting/client/audio_player.h" |
14 #include "remoting/codec/audio_decoder.h" | 14 #include "remoting/codec/audio_decoder.h" |
15 #include "remoting/proto/audio.pb.h" | 15 #include "remoting/proto/audio.pb.h" |
16 | 16 |
17 namespace remoting { | 17 namespace remoting { |
18 | 18 |
19 class AudioDecodeScheduler::Core : public base::RefCountedThreadSafe<Core> { | 19 class AudioDecodeScheduler::Core : public base::RefCountedThreadSafe<Core> { |
20 public: | 20 public: |
21 Core(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, | 21 Core(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, |
22 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, | 22 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, |
23 scoped_ptr<AudioPlayer> audio_player); | 23 std::unique_ptr<AudioPlayer> audio_player); |
24 | 24 |
25 void Initialize(const protocol::SessionConfig& config); | 25 void Initialize(const protocol::SessionConfig& config); |
26 void ProcessAudioPacket(scoped_ptr<AudioPacket> packet, | 26 void ProcessAudioPacket(std::unique_ptr<AudioPacket> packet, |
27 const base::Closure& done); | 27 const base::Closure& done); |
28 | 28 |
29 // Called by AudioDecodeScheduler when it is destroyed. | 29 // Called by AudioDecodeScheduler when it is destroyed. |
30 void Detach(); | 30 void Detach(); |
31 | 31 |
32 private: | 32 private: |
33 friend class base::RefCountedThreadSafe<Core>; | 33 friend class base::RefCountedThreadSafe<Core>; |
34 | 34 |
35 virtual ~Core(); | 35 virtual ~Core(); |
36 | 36 |
37 // Called on the audio decoder thread. | 37 // Called on the audio decoder thread. |
38 void DecodePacket(scoped_ptr<AudioPacket> packet, const base::Closure& done); | 38 void DecodePacket(std::unique_ptr<AudioPacket> packet, |
| 39 const base::Closure& done); |
39 | 40 |
40 // Called on the main thread. | 41 // Called on the main thread. |
41 void ProcessDecodedPacket(scoped_ptr<AudioPacket> packet, | 42 void ProcessDecodedPacket(std::unique_ptr<AudioPacket> packet, |
42 const base::Closure& done); | 43 const base::Closure& done); |
43 | 44 |
44 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_; | 45 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_; |
45 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner_; | 46 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner_; |
46 scoped_ptr<AudioDecoder> decoder_; | 47 std::unique_ptr<AudioDecoder> decoder_; |
47 scoped_ptr<AudioPlayer> audio_player_; | 48 std::unique_ptr<AudioPlayer> audio_player_; |
48 | 49 |
49 DISALLOW_COPY_AND_ASSIGN(Core); | 50 DISALLOW_COPY_AND_ASSIGN(Core); |
50 }; | 51 }; |
51 | 52 |
52 AudioDecodeScheduler::Core::Core( | 53 AudioDecodeScheduler::Core::Core( |
53 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, | 54 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, |
54 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, | 55 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, |
55 scoped_ptr<AudioPlayer> audio_player) | 56 std::unique_ptr<AudioPlayer> audio_player) |
56 : main_task_runner_(main_task_runner), | 57 : main_task_runner_(main_task_runner), |
57 audio_decode_task_runner_(audio_decode_task_runner), | 58 audio_decode_task_runner_(audio_decode_task_runner), |
58 audio_player_(std::move(audio_player)) {} | 59 audio_player_(std::move(audio_player)) {} |
59 | 60 |
60 AudioDecodeScheduler::Core::~Core() {} | 61 AudioDecodeScheduler::Core::~Core() {} |
61 | 62 |
62 void AudioDecodeScheduler::Core::Initialize( | 63 void AudioDecodeScheduler::Core::Initialize( |
63 const protocol::SessionConfig& config) { | 64 const protocol::SessionConfig& config) { |
64 DCHECK(main_task_runner_->BelongsToCurrentThread()); | 65 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
65 decoder_.reset(AudioDecoder::CreateAudioDecoder(config).release()); | 66 decoder_.reset(AudioDecoder::CreateAudioDecoder(config).release()); |
66 } | 67 } |
67 | 68 |
68 void AudioDecodeScheduler::Core::ProcessAudioPacket( | 69 void AudioDecodeScheduler::Core::ProcessAudioPacket( |
69 scoped_ptr<AudioPacket> packet, | 70 std::unique_ptr<AudioPacket> packet, |
70 const base::Closure& done) { | 71 const base::Closure& done) { |
71 DCHECK(main_task_runner_->BelongsToCurrentThread()); | 72 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
72 audio_decode_task_runner_->PostTask(FROM_HERE, base::Bind( | 73 audio_decode_task_runner_->PostTask(FROM_HERE, base::Bind( |
73 &AudioDecodeScheduler::Core::DecodePacket, this, | 74 &AudioDecodeScheduler::Core::DecodePacket, this, |
74 base::Passed(&packet), done)); | 75 base::Passed(&packet), done)); |
75 } | 76 } |
76 | 77 |
77 void AudioDecodeScheduler::Core::Detach() { | 78 void AudioDecodeScheduler::Core::Detach() { |
78 DCHECK(main_task_runner_->BelongsToCurrentThread()); | 79 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
79 audio_player_.reset(); | 80 audio_player_.reset(); |
80 } | 81 } |
81 | 82 |
82 void AudioDecodeScheduler::Core::DecodePacket( | 83 void AudioDecodeScheduler::Core::DecodePacket( |
83 scoped_ptr<AudioPacket> packet, | 84 std::unique_ptr<AudioPacket> packet, |
84 const base::Closure& done) { | 85 const base::Closure& done) { |
85 DCHECK(audio_decode_task_runner_->BelongsToCurrentThread()); | 86 DCHECK(audio_decode_task_runner_->BelongsToCurrentThread()); |
86 scoped_ptr<AudioPacket> decoded_packet = decoder_->Decode(std::move(packet)); | 87 std::unique_ptr<AudioPacket> decoded_packet = |
| 88 decoder_->Decode(std::move(packet)); |
87 | 89 |
88 main_task_runner_->PostTask(FROM_HERE, base::Bind( | 90 main_task_runner_->PostTask(FROM_HERE, base::Bind( |
89 &AudioDecodeScheduler::Core::ProcessDecodedPacket, this, | 91 &AudioDecodeScheduler::Core::ProcessDecodedPacket, this, |
90 base::Passed(&decoded_packet), done)); | 92 base::Passed(&decoded_packet), done)); |
91 } | 93 } |
92 | 94 |
93 void AudioDecodeScheduler::Core::ProcessDecodedPacket( | 95 void AudioDecodeScheduler::Core::ProcessDecodedPacket( |
94 scoped_ptr<AudioPacket> packet, | 96 std::unique_ptr<AudioPacket> packet, |
95 const base::Closure& done) { | 97 const base::Closure& done) { |
96 DCHECK(main_task_runner_->BelongsToCurrentThread()); | 98 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
97 // Only process |packet| if it is non-null. | 99 // Only process |packet| if it is non-null. |
98 if (packet.get() && audio_player_.get()) | 100 if (packet.get() && audio_player_.get()) |
99 audio_player_->ProcessAudioPacket(std::move(packet)); | 101 audio_player_->ProcessAudioPacket(std::move(packet)); |
100 done.Run(); | 102 done.Run(); |
101 } | 103 } |
102 | 104 |
103 AudioDecodeScheduler::AudioDecodeScheduler( | 105 AudioDecodeScheduler::AudioDecodeScheduler( |
104 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, | 106 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, |
105 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, | 107 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner, |
106 scoped_ptr<AudioPlayer> audio_player) | 108 std::unique_ptr<AudioPlayer> audio_player) |
107 : core_(new Core(main_task_runner, audio_decode_task_runner, | 109 : core_(new Core(main_task_runner, |
108 std::move(audio_player))) { | 110 audio_decode_task_runner, |
109 } | 111 std::move(audio_player))) {} |
110 | 112 |
111 AudioDecodeScheduler::~AudioDecodeScheduler() { | 113 AudioDecodeScheduler::~AudioDecodeScheduler() { |
112 core_->Detach(); | 114 core_->Detach(); |
113 } | 115 } |
114 | 116 |
115 void AudioDecodeScheduler::Initialize(const protocol::SessionConfig& config) { | 117 void AudioDecodeScheduler::Initialize(const protocol::SessionConfig& config) { |
116 core_->Initialize(config); | 118 core_->Initialize(config); |
117 } | 119 } |
118 | 120 |
119 void AudioDecodeScheduler::ProcessAudioPacket(scoped_ptr<AudioPacket> packet, | 121 void AudioDecodeScheduler::ProcessAudioPacket( |
120 const base::Closure& done) { | 122 std::unique_ptr<AudioPacket> packet, |
| 123 const base::Closure& done) { |
121 core_->ProcessAudioPacket(std::move(packet), done); | 124 core_->ProcessAudioPacket(std::move(packet), done); |
122 } | 125 } |
123 | 126 |
124 } // namespace remoting | 127 } // namespace remoting |
OLD | NEW |