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