/* * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "rtp_receiver_audio.h" #include //assert #include // memcpy() #include // pow() #include "critical_section_wrapper.h" namespace webrtc { RTPReceiverAudio::RTPReceiverAudio(const WebRtc_Word32 id): _id(id), _lastReceivedFrequency(8000), _telephoneEvent(false), _telephoneEventForwardToDecoder(false), _telephoneEventDetectEndOfTone(false), _telephoneEventPayloadType(-1), _cngNBPayloadType(-1), _cngWBPayloadType(-1), _cngSWBPayloadType(-1), _cngFBPayloadType(-1), _cngPayloadType(-1), _G722PayloadType(-1), _lastReceivedG722(false), _criticalSectionFeedback(CriticalSectionWrapper::CreateCriticalSection()), _cbAudioFeedback(NULL) { } RTPReceiverAudio::~RTPReceiverAudio() { delete _criticalSectionFeedback; } WebRtc_Word32 RTPReceiverAudio::RegisterIncomingAudioCallback(RtpAudioFeedback* incomingMessagesCallback) { CriticalSectionScoped lock(_criticalSectionFeedback); _cbAudioFeedback = incomingMessagesCallback; return 0; } WebRtc_UWord32 RTPReceiverAudio::AudioFrequency() const { if(_lastReceivedG722) { return 8000; } return _lastReceivedFrequency; } // Outband TelephoneEvent(DTMF) detection WebRtc_Word32 RTPReceiverAudio::SetTelephoneEventStatus(const bool enable, const bool forwardToDecoder, const bool detectEndOfTone) { _telephoneEvent= enable; _telephoneEventDetectEndOfTone = detectEndOfTone; _telephoneEventForwardToDecoder = forwardToDecoder; return 0; } // Is outband TelephoneEvent(DTMF) turned on/off? bool RTPReceiverAudio::TelephoneEvent() const { return _telephoneEvent; } // Is forwarding of outband telephone events turned on/off? bool RTPReceiverAudio::TelephoneEventForwardToDecoder() const { return _telephoneEventForwardToDecoder; } bool RTPReceiverAudio::TelephoneEventPayloadType(const WebRtc_Word8 payloadType) const { return (_telephoneEventPayloadType == payloadType)?true:false; } bool RTPReceiverAudio::CNGPayloadType(const WebRtc_Word8 payloadType, WebRtc_UWord32& frequency) { // We can have four CNG on 8000Hz, 16000Hz, 32000Hz and 48000Hz. if(_cngNBPayloadType == payloadType) { frequency = 8000; if ((_cngPayloadType != -1) &&(_cngPayloadType !=_cngNBPayloadType)) { ResetStatistics(); } _cngPayloadType = _cngNBPayloadType; return true; } else if(_cngWBPayloadType == payloadType) { // if last received codec is G.722 we must use frequency 8000 if(_lastReceivedG722) { frequency = 8000; } else { frequency = 16000; } if ((_cngPayloadType != -1) &&(_cngPayloadType !=_cngWBPayloadType)) { ResetStatistics(); } _cngPayloadType = _cngWBPayloadType; return true; }else if(_cngSWBPayloadType == payloadType) { frequency = 32000; if ((_cngPayloadType != -1) &&(_cngPayloadType !=_cngSWBPayloadType)) { ResetStatistics(); } _cngPayloadType = _cngSWBPayloadType; return true; }else if(_cngFBPayloadType == payloadType) { frequency = 48000; if ((_cngPayloadType != -1) &&(_cngPayloadType !=_cngFBPayloadType)) { ResetStatistics(); } _cngPayloadType = _cngFBPayloadType; return true; }else { // not CNG if(_G722PayloadType == payloadType) { _lastReceivedG722 = true; }else { _lastReceivedG722 = false; } } return false; } /* Sample based or frame based codecs based on RFC 3551 NOTE! There is one error in the RFC, stating G.722 uses 8 bits/samples. The correct rate is 4 bits/sample. name of sampling default encoding sample/frame bits/sample rate ms/frame ms/packet Sample based audio codecs DVI4 sample 4 var. 20 G722 sample 4 16,000 20 G726-40 sample 5 8,000 20 G726-32 sample 4 8,000 20 G726-24 sample 3 8,000 20 G726-16 sample 2 8,000 20 L8 sample 8 var. 20 L16 sample 16 var. 20 PCMA sample 8 var. 20 PCMU sample 8 var. 20 Frame based audio codecs G723 frame N/A 8,000 30 30 G728 frame N/A 8,000 2.5 20 G729 frame N/A 8,000 10 20 G729D frame N/A 8,000 10 20 G729E frame N/A 8,000 10 20 GSM frame N/A 8,000 20 20 GSM-EFR frame N/A 8,000 20 20 LPC frame N/A 8,000 20 20 MPA frame N/A var. var. G7221 frame N/A */ ModuleRTPUtility::Payload* RTPReceiverAudio::RegisterReceiveAudioPayload( const char payloadName[RTP_PAYLOAD_NAME_SIZE], const WebRtc_Word8 payloadType, const WebRtc_UWord32 frequency, const WebRtc_UWord8 channels, const WebRtc_UWord32 rate) { if (ModuleRTPUtility::StringCompare(payloadName, "telephone-event", 15)) { _telephoneEventPayloadType = payloadType; } if (ModuleRTPUtility::StringCompare(payloadName, "cn", 2)) { // we can have three CNG on 8000Hz, 16000Hz and 32000Hz if(frequency == 8000){ _cngNBPayloadType = payloadType; } else if(frequency == 16000) { _cngWBPayloadType = payloadType; } else if(frequency == 32000) { _cngSWBPayloadType = payloadType; } else if(frequency == 48000) { _cngFBPayloadType = payloadType; } else { assert(false); return NULL; } } ModuleRTPUtility::Payload* payload = new ModuleRTPUtility::Payload; payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0; strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1); payload->typeSpecific.Audio.frequency = frequency; payload->typeSpecific.Audio.channels = channels; payload->typeSpecific.Audio.rate = rate; payload->audio = true; return payload; } // we are not allowed to have any critsects when calling CallbackOfReceivedPayloadData WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific(WebRtcRTPHeader* rtpHeader, const WebRtc_UWord8* payloadData, const WebRtc_UWord16 payloadLength, const ModuleRTPUtility::AudioPayload& audioSpecific, const bool isRED) { WebRtc_UWord8 newEvents[MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS]; WebRtc_UWord8 removedEvents[MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS]; WebRtc_UWord8 numberOfNewEvents = 0; WebRtc_UWord8 numberOfRemovedEvents = 0; bool telephoneEventPacket = TelephoneEventPayloadType(rtpHeader->header.payloadType); if(payloadLength == 0) { return 0; } { CriticalSectionScoped lock(_criticalSectionFeedback); if(telephoneEventPacket) { // RFC 4733 2.3 /* 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | event |E|R| volume | duration | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ if(payloadLength % 4 != 0) { return -1; } WebRtc_UWord8 numberOfEvents = payloadLength / 4; // sanity if(numberOfEvents >= MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS) { numberOfEvents = MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS; } for (int n = 0; n < numberOfEvents; n++) { bool end = (payloadData[(4*n)+1] & 0x80)? true:false; std::set::iterator event = _telephoneEventReported.find(payloadData[4*n]); if(event != _telephoneEventReported.end()) { // we have already seen this event if(end) { removedEvents[numberOfRemovedEvents]= payloadData[4*n]; numberOfRemovedEvents++; _telephoneEventReported.erase(payloadData[4*n]); } }else { if(end) { // don't add if it's a end of a tone }else { newEvents[numberOfNewEvents] = payloadData[4*n]; numberOfNewEvents++; _telephoneEventReported.insert(payloadData[4*n]); } } } // RFC 4733 2.5.1.3 & 2.5.2.3 Long-Duration Events // should not be a problem since we don't care about the duration // RFC 4733 See 2.5.1.5. & 2.5.2.4. Multiple Events in a Packet } if(_telephoneEvent && _cbAudioFeedback) { for (int n = 0; n < numberOfNewEvents; n++) { _cbAudioFeedback->OnReceivedTelephoneEvent(_id, newEvents[n], false); } if(_telephoneEventDetectEndOfTone) { for (int n = 0; n < numberOfRemovedEvents; n++) { _cbAudioFeedback->OnReceivedTelephoneEvent(_id, removedEvents[n], true); } } } } if(! telephoneEventPacket ) { _lastReceivedFrequency = audioSpecific.frequency; } // Check if this is a CNG packet, receiver might want to know WebRtc_UWord32 dummy; if(CNGPayloadType(rtpHeader->header.payloadType, dummy)) { rtpHeader->type.Audio.isCNG=true; rtpHeader->frameType = kAudioFrameCN; }else { rtpHeader->frameType = kAudioFrameSpeech; rtpHeader->type.Audio.isCNG=false; } // check if it's a DTMF event, hence something we can playout if(telephoneEventPacket) { if(!_telephoneEventForwardToDecoder) { // don't forward event to decoder return 0; } std::set::iterator first = _telephoneEventReported.begin(); if(first != _telephoneEventReported.end() && *first > 15) { // don't forward non DTMF events return 0; } } if(isRED && !(payloadData[0] & 0x80)) { // we recive only one frame packed in a RED packet remove the RED wrapper rtpHeader->header.payloadType = payloadData[0]; // only one frame in the RED strip the one byte to help NetEq return CallbackOfReceivedPayloadData(payloadData+1, payloadLength-1, rtpHeader); } rtpHeader->type.Audio.channel = audioSpecific.channels; return CallbackOfReceivedPayloadData(payloadData, payloadLength, rtpHeader); } } // namespace webrtc