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