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