1 // Copyright 2013 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 #ifndef MEDIA_CAST_AUDIO_RECEIVER_AUDIO_RECEIVER_H_ 6 #define MEDIA_CAST_AUDIO_RECEIVER_AUDIO_RECEIVER_H_ 7 8 #include "base/basictypes.h" 9 #include "base/callback.h" 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/threading/non_thread_safe.h" 14 #include "base/time/tick_clock.h" 15 #include "base/time/time.h" 16 #include "media/cast/cast_config.h" 17 #include "media/cast/cast_environment.h" 18 #include "media/cast/cast_receiver.h" 19 #include "media/cast/rtcp/rtcp.h" // RtcpCastMessage 20 #include "media/cast/rtp_receiver/rtp_receiver_defines.h" // RtpCastHeader 21 22 namespace crypto { 23 class Encryptor; 24 } 25 26 namespace media { 27 namespace cast { 28 29 class AudioDecoder; 30 class Framer; 31 class LocalRtpAudioData; 32 class LocalRtpAudioFeedback; 33 class PacedPacketSender; 34 class RtpReceiver; 35 class RtpReceiverStatistics; 36 37 struct DecodedAudioCallbackData { 38 DecodedAudioCallbackData(); 39 ~DecodedAudioCallbackData(); 40 int number_of_10ms_blocks; 41 int desired_frequency; 42 AudioFrameDecodedCallback callback; 43 }; 44 45 // This class is not thread safe. Should only be called from the Main cast 46 // thread. 47 class AudioReceiver : public base::NonThreadSafe, 48 public base::SupportsWeakPtr<AudioReceiver> { 49 public: 50 AudioReceiver(scoped_refptr<CastEnvironment> cast_environment, 51 const AudioReceiverConfig& audio_config, 52 PacedPacketSender* const packet_sender); 53 54 virtual ~AudioReceiver(); 55 56 // Extract a raw audio frame from the cast receiver. 57 // Actual decoding will be preformed on a designated audio_decoder thread. 58 void GetRawAudioFrame(int number_of_10ms_blocks, 59 int desired_frequency, 60 const AudioFrameDecodedCallback& callback); 61 62 // Extract an encoded audio frame from the cast receiver. 63 void GetEncodedAudioFrame(const AudioFrameEncodedCallback& callback); 64 65 // Should only be called from the main cast thread. 66 void IncomingPacket(const uint8* packet, size_t length, 67 const base::Closure callback); 68 69 protected: 70 void IncomingParsedRtpPacket(const uint8* payload_data, 71 size_t payload_size, 72 const RtpCastHeader& rtp_header); 73 private: 74 friend class LocalRtpAudioData; 75 friend class LocalRtpAudioFeedback; 76 77 void CastFeedback(const RtcpCastMessage& cast_message); 78 79 // Time to pull out the audio even though we are missing data. 80 void PlayoutTimeout(); 81 82 bool PostEncodedAudioFrame(const AudioFrameEncodedCallback& callback, 83 uint32 rtp_timestamp, 84 bool next_frame, 85 scoped_ptr<EncodedAudioFrame>* encoded_frame); 86 87 // Actual decoding implementation - should be called under the audio decoder 88 // thread. 89 void DecodeAudioFrameThread(int number_of_10ms_blocks, 90 int desired_frequency, 91 const AudioFrameDecodedCallback callback); 92 void ReturnDecodedFrameWithPlayoutDelay( 93 scoped_ptr<PcmAudioFrame> audio_frame, uint32 rtp_timestamp, 94 const AudioFrameDecodedCallback callback); 95 96 // Return the playout time based on the current time and rtp timestamp. 97 base::TimeTicks GetPlayoutTime(base::TimeTicks now, uint32 rtp_timestamp); 98 99 void InitializeTimers(); 100 101 // Decrypts the data within the |audio_frame| and replaces the data with the 102 // decrypted string. 103 bool DecryptAudioFrame(scoped_ptr<EncodedAudioFrame>* audio_frame); 104 105 // Schedule the next RTCP report. 106 void ScheduleNextRtcpReport(); 107 108 // Actually send the next RTCP report. 109 void SendNextRtcpReport(); 110 111 // Schedule timing for the next cast message. 112 void ScheduleNextCastMessage(); 113 114 // Actually send the next cast message. 115 void SendNextCastMessage(); 116 117 scoped_refptr<CastEnvironment> cast_environment_; 118 base::WeakPtrFactory<AudioReceiver> weak_factory_; 119 120 const AudioCodec codec_; 121 const int frequency_; 122 base::TimeDelta target_delay_delta_; 123 scoped_ptr<Framer> audio_buffer_; 124 scoped_ptr<AudioDecoder> audio_decoder_; 125 scoped_ptr<LocalRtpAudioData> incoming_payload_callback_; 126 scoped_ptr<LocalRtpAudioFeedback> incoming_payload_feedback_; 127 scoped_ptr<RtpReceiver> rtp_receiver_; 128 scoped_ptr<Rtcp> rtcp_; 129 scoped_ptr<RtpReceiverStatistics> rtp_audio_receiver_statistics_; 130 base::TimeDelta time_offset_; 131 base::TimeTicks time_first_incoming_packet_; 132 uint32 first_incoming_rtp_timestamp_; 133 scoped_ptr<crypto::Encryptor> decryptor_; 134 std::string iv_mask_; 135 136 std::list<AudioFrameEncodedCallback> queued_encoded_callbacks_; 137 std::list<DecodedAudioCallbackData> queued_decoded_callbacks_; 138 }; 139 140 } // namespace cast 141 } // namespace media 142 143 #endif // MEDIA_CAST_AUDIO_RECEIVER_AUDIO_RECEIVER_H_ 144