OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include "webrtc/common_types.h" |
| 12 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h" |
| 13 #include "webrtc/modules/include/module_common_types.h" |
| 14 #include "webrtc/modules/utility/source/coder.h" |
| 15 |
| 16 namespace webrtc { |
| 17 namespace { |
| 18 AudioCodingModule::Config GetAcmConfig(uint32_t id) { |
| 19 AudioCodingModule::Config config; |
| 20 // This class does not handle muted output. |
| 21 config.neteq_config.enable_muted_state = false; |
| 22 config.id = id; |
| 23 config.decoder_factory = CreateBuiltinAudioDecoderFactory(); |
| 24 return config; |
| 25 } |
| 26 } // namespace |
| 27 |
| 28 AudioCoder::AudioCoder(uint32_t instance_id) |
| 29 : acm_(AudioCodingModule::Create(GetAcmConfig(instance_id))), |
| 30 receive_codec_(), |
| 31 encode_timestamp_(0), |
| 32 encoded_data_(nullptr), |
| 33 encoded_length_in_bytes_(0), |
| 34 decode_timestamp_(0) { |
| 35 acm_->InitializeReceiver(); |
| 36 acm_->RegisterTransportCallback(this); |
| 37 } |
| 38 |
| 39 AudioCoder::~AudioCoder() {} |
| 40 |
| 41 int32_t AudioCoder::SetEncodeCodec(const CodecInst& codec_inst) { |
| 42 const bool success = codec_manager_.RegisterEncoder(codec_inst) && |
| 43 codec_manager_.MakeEncoder(&rent_a_codec_, acm_.get()); |
| 44 return success ? 0 : -1; |
| 45 } |
| 46 |
| 47 int32_t AudioCoder::SetDecodeCodec(const CodecInst& codec_inst) { |
| 48 if (acm_->RegisterReceiveCodec(codec_inst, [&] { |
| 49 return rent_a_codec_.RentIsacDecoder(codec_inst.plfreq); |
| 50 }) == -1) { |
| 51 return -1; |
| 52 } |
| 53 memcpy(&receive_codec_, &codec_inst, sizeof(CodecInst)); |
| 54 return 0; |
| 55 } |
| 56 |
| 57 int32_t AudioCoder::Decode(AudioFrame& decoded_audio, |
| 58 uint32_t samp_freq_hz, |
| 59 const int8_t* incoming_payload, |
| 60 size_t payload_length) { |
| 61 if (payload_length > 0) { |
| 62 const uint8_t payload_type = receive_codec_.pltype; |
| 63 decode_timestamp_ += receive_codec_.pacsize; |
| 64 if (acm_->IncomingPayload((const uint8_t*)incoming_payload, payload_length, |
| 65 payload_type, decode_timestamp_) == -1) { |
| 66 return -1; |
| 67 } |
| 68 } |
| 69 bool muted; |
| 70 int32_t ret = |
| 71 acm_->PlayoutData10Ms((uint16_t)samp_freq_hz, &decoded_audio, &muted); |
| 72 RTC_DCHECK(!muted); |
| 73 return ret; |
| 74 } |
| 75 |
| 76 int32_t AudioCoder::PlayoutData(AudioFrame& decoded_audio, |
| 77 uint16_t& samp_freq_hz) { |
| 78 bool muted; |
| 79 int32_t ret = acm_->PlayoutData10Ms(samp_freq_hz, &decoded_audio, &muted); |
| 80 RTC_DCHECK(!muted); |
| 81 return ret; |
| 82 } |
| 83 |
| 84 int32_t AudioCoder::Encode(const AudioFrame& audio, |
| 85 int8_t* encoded_data, |
| 86 size_t& encoded_length_in_bytes) { |
| 87 // Fake a timestamp in case audio doesn't contain a correct timestamp. |
| 88 // Make a local copy of the audio frame since audio is const |
| 89 AudioFrame audio_frame; |
| 90 audio_frame.CopyFrom(audio); |
| 91 audio_frame.timestamp_ = encode_timestamp_; |
| 92 encode_timestamp_ += static_cast<uint32_t>(audio_frame.samples_per_channel_); |
| 93 |
| 94 // For any codec with a frame size that is longer than 10 ms the encoded |
| 95 // length in bytes should be zero until a a full frame has been encoded. |
| 96 encoded_length_in_bytes_ = 0; |
| 97 if (acm_->Add10MsData((AudioFrame&)audio_frame) == -1) { |
| 98 return -1; |
| 99 } |
| 100 encoded_data_ = encoded_data; |
| 101 encoded_length_in_bytes = encoded_length_in_bytes_; |
| 102 return 0; |
| 103 } |
| 104 |
| 105 int32_t AudioCoder::SendData(FrameType /* frame_type */, |
| 106 uint8_t /* payload_type */, |
| 107 uint32_t /* time_stamp */, |
| 108 const uint8_t* payload_data, |
| 109 size_t payload_size, |
| 110 const RTPFragmentationHeader* /* fragmentation*/) { |
| 111 memcpy(encoded_data_, payload_data, sizeof(uint8_t) * payload_size); |
| 112 encoded_length_in_bytes_ = payload_size; |
| 113 return 0; |
| 114 } |
| 115 |
| 116 } // namespace webrtc |
OLD | NEW |