/* Copyright(C) 2007-2021 VoIPobjects (voipobjects.com)
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#if defined(TARGET_WIN) && !defined(NOMINMAX)
#  define NOMINMAX
#endif

#include "../engine_config.h"
#include "MT_AudioReceiver.h"
#include "MT_AudioCodec.h"
#include "MT_CngHelper.h"
#include "../helper/HL_Log.h"
#include "../helper/HL_Time.h"
#include "../audio/Audio_Interface.h"
#include "../audio/Audio_Resampler.h"
#include <cmath>
#include <iostream>

#if !defined(TARGET_ANDROID) && !defined(TARGET_OPENWRT) && !defined(TARGET_WIN) && !defined(TARGET_RPI) && defined(USE_AMR_CODEC)
# include "MT_AmrCodec.h"
#endif

#include <algorithm>

#define LOG_SUBSYSTEM "AudioReceiver"

//#define DUMP_DECODED

using namespace MT;

// ----------------- RtpBuffer::Packet --------------
RtpBuffer::Packet::Packet(const std::shared_ptr<RTPPacket>& packet, int timelength, int rate)
    :mRtp(packet), mTimelength(timelength), mRate(rate)
{
}

std::shared_ptr<RTPPacket> RtpBuffer::Packet::rtp() const
{
    return mRtp;
}

int RtpBuffer::Packet::timelength() const
{
    return mTimelength;
}

int RtpBuffer::Packet::rate() const
{
    return mRate;
}

const std::vector<short>& RtpBuffer::Packet::pcm() const
{
    return mPcm;
}

std::vector<short>& RtpBuffer::Packet::pcm()
{
    return mPcm;
}

// ------------ RtpBuffer ----------------
RtpBuffer::RtpBuffer(Statistics& stat)
    :mStat(stat)
{
    if (mStat.mPacketLoss)
        std::cout << "Warning: packet loss is not zero" << std::endl;
}

RtpBuffer::~RtpBuffer()
{
    ICELogDebug(<< "Number of add packets: " << mAddCounter << ", number of retrieved packets " << mReturnedCounter);
}

void RtpBuffer::setHigh(int milliseconds)
{
    mHigh = milliseconds;
}

int RtpBuffer::high() const
{
    return mHigh;
}

void RtpBuffer::setLow(int milliseconds)
{
    mLow = milliseconds;
}

int RtpBuffer::low() const
{
    return mLow;
}

void RtpBuffer::setPrebuffer(int milliseconds)
{
    mPrebuffer = milliseconds;
}

int RtpBuffer::prebuffer() const
{
    return mPrebuffer;
}

int RtpBuffer::getCount() const
{
    Lock l(mGuard);
    return static_cast<int>(mPacketList.size());
}

bool SequenceSort(const std::shared_ptr<RtpBuffer::Packet>& p1, const std::shared_ptr<RtpBuffer::Packet>& p2)
{
    return p1->rtp()->GetExtendedSequenceNumber() < p2->rtp()->GetExtendedSequenceNumber();
}

std::shared_ptr<RtpBuffer::Packet> RtpBuffer::add(std::shared_ptr<jrtplib::RTPPacket> packet, int timelength, int rate)
{
    if (!packet)
        return std::shared_ptr<Packet>();

    Lock l(mGuard);

    // Update statistics
    if (mLastAddTime == 0.0)
        mLastAddTime = now_ms();
    else
    {
        float t = now_ms();
        mStat.mPacketInterval.process(t - mLastAddTime);
        mLastAddTime = t;
    }
    mStat.mSsrc = static_cast<uint16_t>(packet->GetSSRC());

    // Update jitter
    ICELogMedia(<< "Adding new packet into jitter buffer");
    mAddCounter++;

    // Look for maximum&minimal sequence number; check for dublicates
    unsigned maxno = 0xFFFFFFFF, minno = 0;

    // New sequence number
    unsigned newSeqno = packet->GetExtendedSequenceNumber();

    for (std::shared_ptr<Packet>& p: mPacketList)
    {
        unsigned seqno = p->rtp()->GetExtendedSequenceNumber();

        if (seqno == newSeqno)
        {
            mStat.mDuplicatedRtp++;
            ICELogMedia(<< "Discovered duplicated packet, skipping");
            return std::shared_ptr<Packet>();
        }

        if (seqno > maxno)
            maxno = seqno;
        if (seqno < minno)
            minno = seqno;
    }

    // Get amount of available audio (in milliseconds) in jitter buffer
    int available = findTimelength();

    if (newSeqno > minno || (available < mHigh))
    {
        // Insert into queue
        auto p = std::make_shared<Packet>(packet, timelength, rate);
        mPacketList.push_back(p);

        // Sort again
        std::sort(mPacketList.begin(), mPacketList.end(), SequenceSort);

        // Limit by max timelength
        available = findTimelength();

        if (available > mHigh)
            ICELogMedia(<< "Available " << available << "ms with limit " << mHigh << "ms");

        return p;
    }
    else
    {
        ICELogMedia(<< "Too old packet, skipping");
        mStat.mOldRtp++;

        return std::shared_ptr<Packet>();
    }

    return std::shared_ptr<Packet>();
}

RtpBuffer::FetchResult RtpBuffer::fetch(ResultList& rl)
{
    Lock l(mGuard);

    FetchResult result = FetchResult::NoPacket;
    rl.clear();

    // See if there is enough information in buffer
    int total = findTimelength();

    while (total > mHigh && mPacketList.size() && 0 != mHigh)
    {
        ICELogMedia( << "Dropping RTP packets from jitter buffer");
        total -= mPacketList.front()->timelength();

        // Save it as last packet however - to not confuse loss packet counter
        mFetchedPacket = mPacketList.front();
        mLastSeqno = mPacketList.front()->rtp()->GetExtendedSequenceNumber();

        // Erase from packet list
        mPacketList.erase(mPacketList.begin());

        // Increase number in statistics
        mStat.mPacketDropped++;
    }

    if (total < mLow)
    {
        // Still not prebuffered
        result = FetchResult::NoPacket;
    }
    else
    {
        if (mLastSeqno) // It means we had previous packet
        {
            if (mPacketList.empty())
            {
                result = FetchResult::NoPacket;
                // Don't increase counter of lost packets here; maybe it is DTX
            }
            else
            {
                // Current sequence number ?
                auto& packet = *mPacketList.front();
                uint32_t seqno = packet.rtp()->GetExtendedSequenceNumber();


                // Gap between new packet and previous on
                int gap = (int64_t)seqno - (int64_t)*mLastSeqno - 1;
                gap = std::min(gap, 127);
                if (gap > 0)
                {
                    // std::cout << "Increase the packet loss for SSRC " << std::hex << mSsrc << std::endl;
                    mStat.mPacketLoss++;
                    auto currentTimestamp = std::chrono::microseconds(uint64_t(packet.rtp()->GetReceiveTime().GetDouble() * 1000000));

                    if (mStat.mPacketLossTimeline.empty() || (mStat.mPacketLossTimeline.back().mEndSeqno != seqno))
                        mStat.mPacketLossTimeline.push_back({.mStartSeqno = *mLastSeqno,
                                                             .mEndSeqno = seqno,
                                                             .mGap = gap,
                                                             .mTimestamp = currentTimestamp});

                    mLastSeqno = *mLastSeqno + 1; // As we deal with the audio gap - return the silence and increase last seqno

                    result = FetchResult::Gap;
                }
                else
                {
                    result = FetchResult::RegularPacket;
                    rl.push_back(mPacketList.front());

                    // Save last returned normal packet
                    mFetchedPacket = mPacketList.front();
                    mLastSeqno = mPacketList.front()->rtp()->GetExtendedSequenceNumber();

                    // Remove returned packet from the list
                    mPacketList.erase(mPacketList.begin());
                }
            }
        }
        else
        {
            // See if prebuffer limit is reached
            if (findTimelength() >= mPrebuffer && !mPacketList.empty())
            {
                // Normal packet will be returned
                result = FetchResult::RegularPacket;

                // Put it to output list
                rl.push_back(mPacketList.front());

                // Remember returned packet
                mFetchedPacket = mPacketList.front();
                mLastSeqno = mPacketList.front()->rtp()->GetExtendedSequenceNumber();

                // Remove returned packet from buffer list
                mPacketList.erase(mPacketList.begin());
            }
            else
            {
                ICELogMedia(<< "Jitter buffer was not prebuffered yet; resulting no packet");
                result = FetchResult::NoPacket;
            }
        }
    }

    if (result != FetchResult::NoPacket)
        mReturnedCounter++;

    return result;
}

int RtpBuffer::findTimelength()
{
    int available = 0;
    for (unsigned i = 0; i < mPacketList.size(); i++)
        available += mPacketList[i]->timelength();
    return available;
}

int RtpBuffer::getNumberOfReturnedPackets() const
{
    return mReturnedCounter;
}

int RtpBuffer::getNumberOfAddPackets() const
{
    return mAddCounter;
}

//-------------- Receiver ---------------
Receiver::Receiver(Statistics& stat)
    :mStat(stat)
{
}

Receiver::~Receiver()
{
}

//-------------- AudioReceiver ----------------
AudioReceiver::AudioReceiver(const CodecList::Settings& settings, MT::Statistics &stat)
    :Receiver(stat), mBuffer(stat), mCodecSettings(settings),
      mCodecList(settings)
{
    // Init resamplers
    mResampler8.start(AUDIO_CHANNELS, 8000, AUDIO_SAMPLERATE);
    mResampler16.start(AUDIO_CHANNELS, 16000, AUDIO_SAMPLERATE);
    mResampler32.start(AUDIO_CHANNELS, 32000, AUDIO_SAMPLERATE);
    mResampler48.start(AUDIO_CHANNELS, 48000, AUDIO_SAMPLERATE);

    // Init codecs
    mCodecList.setSettings(settings);
    mCodecList.fillCodecMap(mCodecMap);

#if defined(DUMP_DECODED)
    mDecodedDump = std::make_shared<Audio::WavFileWriter>();
    mDecodedDump->open("decoded.wav", 8000 /*G711*/, AUDIO_CHANNELS);
#endif
}

AudioReceiver::~AudioReceiver()
{
    mResampler8.stop();
    mResampler16.stop();
    mResampler32.stop();
    mResampler48.stop();
    mDecodedDump.reset();
}

// Update codec settings
void AudioReceiver::setCodecSettings(const CodecList::Settings& codecSettings)
{
    if (mCodecSettings == codecSettings)
        return;

    mCodecSettings = codecSettings;
    mCodecList.setSettings(mCodecSettings); // This builds factory list with proper payload types according to payload types in settings

    // Rebuild codec map from factory list
    mCodecList.fillCodecMap(mCodecMap);
}

CodecList::Settings& AudioReceiver::getCodecSettings()
{
    return mCodecSettings;
}

size_t decode_packet(Codec& codec, RTPPacket& p, void* output_buffer, size_t output_capacity)
{
    // How much data was produced
    size_t result = 0;

    // Handle here regular RTP packets
    // Check if payload length is ok
    int tail = codec.rtpLength() ? p.GetPayloadLength() % codec.rtpLength() : 0;

    if (!tail)
    {
        // Find number of frames
        int frame_count = codec.rtpLength() ? p.GetPayloadLength() / codec.rtpLength() : 1;
        int frame_length = codec.rtpLength() ? codec.rtpLength() : (int)p.GetPayloadLength();

        // Save last packet time length
        // mLastPacketTimeLength = mFrameCount * mCodec->frameTime();

        // Decode

        for (int i=0; i < frame_count; i++)
        {
            auto decoded_length = codec.decode(p.GetPayloadData() + i * codec.rtpLength(),
                                               frame_length,
                                               output_buffer,
                                               output_capacity);

            result += decoded_length;
        }
    }
    else
        ICELogMedia(<< "RTP packet with tail.");

    return result;
}

bool AudioReceiver::add(const std::shared_ptr<jrtplib::RTPPacket>& p, Codec** detectedCodec)
{
    // Estimate time length
    int time_length = 0,
        samplerate = 8000,
        payloadLength = p->GetPayloadLength(),
        ptype = p->GetPayloadType();

    ICELogMedia(<< "Adding packet No " << p->GetSequenceNumber());
    // Increase codec counter
    mStat.mCodecCount[ptype]++;

    // Check if codec can be handled
    Codec* codec = nullptr;
    auto codecIter = mCodecMap.find(ptype);
    if (codecIter == mCodecMap.end())
    {
        time_length = 10;
    }
    else
    {
        // Check if codec is creating lazily
        if (!codecIter->second)
        {
            codecIter->second = mCodecList.createCodecByPayloadType(ptype);
        }
        codec = codecIter->second.get();

        // Return pointer to codec if needed.get()
        if (detectedCodec)
            *detectedCodec = codec;

        if (mStat.mCodecName.empty() && codec)
            mStat.mCodecName = codec->name();


        if (!codec)
            time_length = 10;
        else
        if (!codec->rtpLength())
            time_length = codec->frameTime();
        else
            time_length = lround(double(payloadLength) / codec->rtpLength() * codec->frameTime());

        if (codec)
            samplerate = codec->samplerate();
    }

    // Process jitter
    mJitterStats.process(p.get(), samplerate);
    mStat.mJitter = static_cast<float>(mJitterStats.get());

    // Check if packet is CNG
    if (payloadLength >= 1 && payloadLength <= 6 && (ptype == 0 || ptype == 8))
        time_length = mLastPacketTimeLength ? mLastPacketTimeLength : 20;
    else
    // Check if packet is too short from time length side
    if (time_length < 2)
    {
        // It will cause statistics to report about bad RTP packet
        // I have to replay last packet payload here to avoid report about lost packet
        mBuffer.add(p, time_length, samplerate);
        return false;
    }

    // Queue packet to buffer
    auto packet = mBuffer.add(p, time_length, samplerate).get();

    return packet;
}

void AudioReceiver::processDecoded(Audio::DataWindow& output, DecodeOptions options)
{
    // Write to audio dump if requested
    if (mDecodedDump && mDecodedLength)
        mDecodedDump->write(mDecodedFrame, mDecodedLength);

    // Resample to target rate
    makeMonoAndResample(options.mResampleToMainRate ? mCodec->samplerate() : 0, mCodec->channels());

    // Send to output
    output.add(mResampledFrame, mResampledLength);
}

void AudioReceiver::produceSilence(std::chrono::milliseconds length, Audio::DataWindow& output, DecodeOptions options)
{
    // Fill mDecodeBuffer as much as needed and call processDecoded()
    // Depending on used codec mono or stereo silence should be produced
    size_t chunks = length.count() / 10;
    size_t tail = length.count() % 10;
    size_t chunk_size = 10 * sizeof(int16_t) * mCodec->samplerate() / 1000 * mCodec->channels();
    size_t tail_size = tail * sizeof(int16_t) * mCodec->samplerate() / 1000 * mCodec->channels();
    for (size_t i = 0; i < chunks; i++)
    {
        memset(mDecodedFrame, 0, chunk_size);
        mDecodedLength = chunk_size;
        processDecoded(output, options);
    }
    if (tail)
    {
        memset(mDecodedFrame, 0, tail_size);
        mDecodedLength = tail_size;
        processDecoded(output, options);
    }
}

void AudioReceiver::produceCNG(std::chrono::milliseconds length, Audio::DataWindow& output, DecodeOptions options)
{
    int frames100ms = length.count() / 100;
    for (int frameIndex = 0; frameIndex < frames100ms; frameIndex++)
    {
        if (options.mSkipDecode)
            mDecodedLength = 0;
        else
            mDecodedLength = mCngDecoder.produce(mCodec->samplerate(), 100, mDecodedFrame, false);

        if (mDecodedLength)
            processDecoded(output, options);
    }

    // Do not forget about tail!
    int tail = length.count() % 100;
    if (tail)
    {
        if (options.mSkipDecode)
            mDecodedLength = 0;
        else
            mDecodedLength = mCngDecoder.produce(mCodec->samplerate(), tail, reinterpret_cast<short*>(mDecodedFrame), false);

        if (mDecodedLength)
            processDecoded(output, options);
    }
}

AudioReceiver::DecodeResult AudioReceiver::decodeGap(Audio::DataWindow& output, DecodeOptions options)
{
    ICELogDebug(<< "Gap detected.");

    mDecodedLength = mResampledLength = 0;
    if (mCngPacket && mCodec)
    {
        // Synthesize comfort noise. It will be done on AUDIO_SAMPLERATE rate directly to mResampledFrame buffer.
        // Do not forget to send this noise to analysis
        mDecodedLength = mCngDecoder.produce(mCodec->samplerate(), mLastPacketTimeLength,
                                             reinterpret_cast<short*>(mDecodedFrame), false);
    }
    else
    if (mCodec && mFrameCount && !mCodecSettings.mSkipDecode)
    {
        // Do PLC to mDecodedFrame/mDecodedLength
        if (options.mSkipDecode)
            mDecodedLength = 0;
        else
        {
            mDecodedLength = mCodec->plc(mFrameCount, mDecodedFrame, sizeof mDecodedFrame);
            if (!mDecodedLength)
            {
                // PLC is not support or failed
                // So substitute the silence
                size_t nr_of_samples = mCodec->frameTime() * mCodec->samplerate() / 1000 * sizeof(short);
                mDecodedLength = nr_of_samples * sizeof(short);
                memset(mDecodedFrame, 0, mDecodedLength);
            }
        }
    }

    if (mDecodedLength)
    {
        processDecoded(output, options);
        return DecodeResult_Ok;
    }
    else
        return DecodeResult_Skip;
}

AudioReceiver::DecodeResult AudioReceiver::decodePacket(const RtpBuffer::ResultList& rl, Audio::DataWindow& output, DecodeOptions options, int* rate)
{
    DecodeResult result = DecodeResult_Skip;

    mFailedCount = 0;
    for (const std::shared_ptr<RtpBuffer::Packet>& p: rl)
    {
        assert(p);
        // Check if we need to emit silence or CNG - previously CNG packet was detected. Emit CNG audio here if needed.
        if (mLastPacketTimestamp && mLastPacketTimeLength && mCodec)
        {
            int units = p->rtp()->GetTimestamp() - *mLastPacketTimestamp;
            int milliseconds = units / (mCodec->samplerate() / 1000);
            if (milliseconds > mLastPacketTimeLength)
            {
                auto silenceLength = std::chrono::milliseconds(milliseconds - mLastPacketTimeLength);

                if (mCngPacket && options.mFillGapByCNG)
                    produceCNG(silenceLength, output, options);
                else
                    produceSilence(silenceLength, output, options);
            }
        }

        mLastPacketTimestamp = p->rtp()->GetTimestamp();

        // Find codec by payload type
        int ptype = p->rtp()->GetPayloadType();

        // Look into mCodecMap if exists
        auto codecIter = mCodecMap.find(ptype);
        if (codecIter == mCodecMap.end())
            return  {};


        if (!codecIter->second)
            codecIter->second = mCodecList.createCodecByPayloadType(ptype);

        mCodec = codecIter->second;
        if (mCodec)
        {
            if (rate)
                *rate = mCodec->samplerate();

            // Check if it is CNG packet
            if ((ptype == 0 || ptype == 8) && p->rtp()->GetPayloadLength() >= 1 && p->rtp()->GetPayloadLength() <= 6)
            {
                if (options.mSkipDecode)
                    mDecodedLength = 0;
                else
                {
                    mCngPacket = p->rtp();
                    mCngDecoder.decode3389(p->rtp()->GetPayloadData(), p->rtp()->GetPayloadLength());

                    // Emit CNG mLastPacketLength milliseconds
                    mDecodedLength = mCngDecoder.produce(mCodec->samplerate(), mLastPacketTimeLength,
                                                         (short*)mDecodedFrame, true);
                    if (mDecodedLength)
                        processDecoded(output, options);
                }
                result = DecodeResult_Ok;
            }
            else
            {
                // Reset CNG packet as we get regular RTP packet
                mCngPacket.reset();

                // Handle here regular RTP packets
                // Check if payload length is ok
                size_t payload_length = p->rtp()->GetPayloadLength();
                size_t rtp_frame_length = mCodec->rtpLength();

                int tail = rtp_frame_length ? payload_length % rtp_frame_length : 0;

                if (!tail)
                {
                    // Find number of frames
                    mFrameCount = mCodec->rtpLength() ? p->rtp()->GetPayloadLength() / mCodec->rtpLength() : 1;
                    int frameLength = mCodec->rtpLength() ? mCodec->rtpLength() : (int)p->rtp()->GetPayloadLength();

                    // Save last packet time length
                    mLastPacketTimeLength = mFrameCount * mCodec->frameTime();

                    // Decode
                    for (int i=0; i<mFrameCount && !mCodecSettings.mSkipDecode; i++)
                    {
                        if (options.mSkipDecode)
                            mDecodedLength = 0;
                        else
                        {
                            // Decode frame by frame
                            mDecodedLength = mCodec->decode(p->rtp()->GetPayloadData() + i * mCodec->rtpLength(),
                                                            frameLength, mDecodedFrame, sizeof mDecodedFrame);
                            if (mDecodedLength > 0)
                                processDecoded(output, options);
                        }
                    }
                    result = mFrameCount > 0 ? DecodeResult_Ok : DecodeResult_Skip;

                    // Check for bitrate counter
                    updateAmrCodecStats(mCodec.get());
                }
                else
                {
                    // RTP packet with tail - it should not happen
                    result = DecodeResult_BadPacket;
                }
            }
        }
    }
    return result;
}

AudioReceiver::DecodeResult AudioReceiver::decodeNone(Audio::DataWindow& output, DecodeOptions options)
{
    // ICELogDebug(<< "No packet available in jitter buffer");
    mFailedCount++;
    return DecodeResult_Skip;
}

AudioReceiver::DecodeResult AudioReceiver::getAudio(Audio::DataWindow& output, DecodeOptions options, int* rate)
{
    DecodeResult result = DecodeResult_Skip;

    // Get next packet from buffer
    RtpBuffer::ResultList rl;
    RtpBuffer::FetchResult fr = mBuffer.fetch(rl);
    switch (fr)
    {
    case RtpBuffer::FetchResult::Gap:           result = decodeGap(output, options);                break;
    case RtpBuffer::FetchResult::NoPacket:      result = decodeNone(output, options);               break;
    case RtpBuffer::FetchResult::RegularPacket: result = decodePacket(rl, output, options, rate);   break;
    default:
        assert(0);
    }

    if (result == DecodeResult_Ok)
    {
        // Decode statistics
        if (!mLastDecodeTimestamp)
            mLastDecodeTimestamp = std::chrono::steady_clock::now();
        else
        {
            auto t = std::chrono::steady_clock::now();
            mStat.mDecodingInterval.process(std::chrono::duration_cast<std::chrono::milliseconds>(t - *mLastDecodeTimestamp).count());
            mLastDecodeTimestamp = t;
        }
    }
    return result;
}

void AudioReceiver::makeMonoAndResample(int rate, int channels)
{
    // Make mono from stereo - engine works with mono only for now
    mConvertedLength = 0;
    if (channels != AUDIO_CHANNELS)
    {
        if (channels == 1)
            mConvertedLength = Audio::ChannelConverter::monoToStereo(mDecodedFrame, mDecodedLength, mConvertedFrame, mDecodedLength * 2);
        else
            mDecodedLength = Audio::ChannelConverter::stereoToMono(mDecodedFrame, mDecodedLength, mDecodedFrame, mDecodedLength / 2);
    }

    void* frames = mConvertedLength ? mConvertedFrame : mDecodedFrame;
    unsigned length = mConvertedLength ? mConvertedLength : mDecodedLength;

    Audio::Resampler* r = nullptr;
    switch (rate)
    {
    case 8000:     r = &mResampler8; break;
    case 16000:    r = &mResampler16; break;
    case 32000:    r = &mResampler32; break;
    case 48000:    r = &mResampler48; break;
    default:
        memcpy(mResampledFrame, frames, length);
        mResampledLength = length;
        return;
    }

    size_t processedInput = 0;
    mResampledLength = r->processBuffer(frames, length, processedInput, mResampledFrame, r->getDestLength(length));
    // processedInput result value is ignored - it is always equal to length as internal sample rate is 8/16/32/48K
}

Codec* AudioReceiver::findCodec(int payloadType)
{
    MT::CodecMap::const_iterator codecIter = mCodecMap.find(payloadType);
    if (codecIter == mCodecMap.end())
        return nullptr;

    return codecIter->second.get();
}


void AudioReceiver::updateAmrCodecStats(Codec* c)
{
#if !defined(TARGET_ANDROID) && !defined(TARGET_OPENWRT) && !defined(TARGET_WIN) && !defined(TARGET_RPI) && defined(USE_AMR_CODEC)
    AmrNbCodec* nb = dynamic_cast<AmrNbCodec*>(c);
    AmrWbCodec* wb = dynamic_cast<AmrWbCodec*>(c);

    if (nb != nullptr)
        mStat.mBitrateSwitchCounter = nb->getSwitchCounter();
    else
    if (wb != nullptr)
        mStat.mBitrateSwitchCounter = wb->getSwitchCounter();
#endif
}

int AudioReceiver::getSize() const
{
    int result = 0;
    result += sizeof(*this) + mResampler8.getSize() + mResampler16.getSize() + mResampler32.getSize()
            + mResampler48.getSize();

    if (mCodec)
        result += mCodec->getSize();

    return result;
}

int AudioReceiver::timelengthFor(jrtplib::RTPPacket& p)
{
    CodecMap::iterator codecIter = mCodecMap.find(p.GetPayloadType());
    if (codecIter == mCodecMap.end())
        return 0;

    PCodec codec = codecIter->second;
    if (codec)
    {
        int frame_count = 0;
        if (codec->rtpLength() != 0)
        {
            frame_count = static_cast<int>(p.GetPayloadLength() / codec->rtpLength());
            if (p.GetPayloadType() == 9/*G729A silence*/ && p.GetPayloadLength() % codec->rtpLength())
                frame_count++;
        }
        else
            frame_count = 1;

        return frame_count * codec->frameTime();
    }
    else
        return 0;
}

int AudioReceiver::samplerateFor(jrtplib::RTPPacket& p)
{
    CodecMap::iterator codecIter = mCodecMap.find(p.GetPayloadType());
    if (codecIter != mCodecMap.end())
    {
        PCodec codec = codecIter->second;
        if (codec)
            return codec->samplerate();
    }

    return 8000;
}

// ----------------------- DtmfReceiver -------------------
DtmfReceiver::DtmfReceiver(Statistics& stat)
    :Receiver(stat)
{}

DtmfReceiver::~DtmfReceiver()
{}

void DtmfReceiver::add(std::shared_ptr<RTPPacket> /*p*/)
{}