remoting/client/audio_decode_scheduler.cc - Issue 2384063004: Move audio decoding to protocol layer

Side by Side Diff: remoting/client/audio_decode_scheduler.cc

Issue 2384063004: Move audio decoding to protocol layer (Closed)

Patch Set: Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
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

3 // found in the LICENSE file.

4

5 #include "remoting/client/audio_decode_scheduler.h"

6

7 #include <utility>

8

9 #include "base/bind.h"

10 #include "base/location.h"

11 #include "base/macros.h"

12 #include "base/memory/weak_ptr.h"

13 #include "base/single_thread_task_runner.h"

14 #include "remoting/client/audio_consumer.h"

15 #include "remoting/codec/audio_decoder.h"

16 #include "remoting/proto/audio.pb.h"

17

18 namespace remoting {

19

20 class AudioDecodeScheduler::Core : public base::RefCountedThreadSafe<Core> {

21 public:

22 Core(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,

23 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,

24 base::WeakPtr<AudioConsumer> audio_consumer);

25

26 void Initialize(const protocol::SessionConfig& config);

27 void ProcessAudioPacket(std::unique_ptr<AudioPacket> packet,

28 const base::Closure& done);

29

30 private:

31 friend class base::RefCountedThreadSafe<Core>;

32

33 virtual ~Core();

34

35 // Called on the audio decoder thread.

36 void DecodePacket(std::unique_ptr<AudioPacket> packet,

37 const base::Closure& done);

38

39 // Called on the main thread.

40 void ProcessDecodedPacket(std::unique_ptr<AudioPacket> packet,

41 const base::Closure& done);

42

43 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;

44 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner_;

45 std::unique_ptr<AudioDecoder> decoder_;

46 base::WeakPtr<AudioConsumer> audio_consumer_;

47

48 DISALLOW_COPY_AND_ASSIGN(Core);

49 };

50

51 AudioDecodeScheduler::Core::Core(

52 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,

53 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,

54 base::WeakPtr<AudioConsumer> audio_consumer)

55 : main_task_runner_(main_task_runner),

56 audio_decode_task_runner_(audio_decode_task_runner),

57 audio_consumer_(audio_consumer) {}

58

59 AudioDecodeScheduler::Core::~Core() {}

60

61 void AudioDecodeScheduler::Core::Initialize(

62 const protocol::SessionConfig& config) {

63 DCHECK(main_task_runner_->BelongsToCurrentThread());

64 decoder_.reset(AudioDecoder::CreateAudioDecoder(config).release());

65 }

66

67 void AudioDecodeScheduler::Core::ProcessAudioPacket(

68 std::unique_ptr<AudioPacket> packet,

69 const base::Closure& done) {

70 DCHECK(main_task_runner_->BelongsToCurrentThread());

71 audio_decode_task_runner_->PostTask(FROM_HERE, base::Bind(

72 &AudioDecodeScheduler::Core::DecodePacket, this,

73 base::Passed(&packet), done));

74 }

75

76 void AudioDecodeScheduler::Core::DecodePacket(

77 std::unique_ptr<AudioPacket> packet,

78 const base::Closure& done) {

79 DCHECK(audio_decode_task_runner_->BelongsToCurrentThread());

80 std::unique_ptr<AudioPacket> decoded_packet =

81 decoder_->Decode(std::move(packet));

82

83 main_task_runner_->PostTask(FROM_HERE, base::Bind(

84 &AudioDecodeScheduler::Core::ProcessDecodedPacket, this,

85 base::Passed(&decoded_packet), done));

86 }

87

88 void AudioDecodeScheduler::Core::ProcessDecodedPacket(

89 std::unique_ptr<AudioPacket> packet,

90 const base::Closure& done) {

91 DCHECK(main_task_runner_->BelongsToCurrentThread());

92 // Only process \|packet\| if it is non-null.

93 if (packet.get() && audio_consumer_) {

94 audio_consumer_->AddAudioPacket(std::move(packet));

95 }

96 done.Run();

97 }

98

99 AudioDecodeScheduler::AudioDecodeScheduler(

100 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,

101 scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,

102 base::WeakPtr<AudioConsumer> audio_consumer)

103 : core_(new Core(main_task_runner,

104 audio_decode_task_runner,

105 audio_consumer)) {}

106

107 AudioDecodeScheduler::~AudioDecodeScheduler() {

108 }

109

110 void AudioDecodeScheduler::Initialize(const protocol::SessionConfig& config) {

111 core_->Initialize(config);

112 }

113

114 void AudioDecodeScheduler::ProcessAudioPacket(

115 std::unique_ptr<AudioPacket> packet,

116 const base::Closure& done) {

117 core_->ProcessAudioPacket(std::move(packet), done);

118 }

119

120 } // namespace remoting

OLD	NEW