/*
 *  Copyright (c) 2011 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.
 */

// 'conversion' conversion from 'type1' to 'type2', possible loss of data
#pragma warning(disable: 4267)

#include <stdio.h>

#include "acm_codec_database.h"
#include "acm_common_defs.h"
#include "trace.h"

// Includes needed to get version info
// and to create the codecs
#include "acm_pcma.h"
#include "acm_pcmu.h"
#include "g711_interface.h"
#include "webrtc_neteq.h"
#include "webrtc_cng.h"
#include "acm_cng.h"
#ifdef WEBRTC_CODEC_AVT
    #include "acm_dtmf_playout.h"
#endif
#ifdef WEBRTC_CODEC_RED
    #include "acm_red.h"
#endif
#ifdef WEBRTC_CODEC_ILBC
    #include "acm_ilbc.h"
    #include "ilbc.h"
#endif
#ifdef WEBRTC_CODEC_ISAC
    #include "acm_isac.h"
    #include "acm_isac_macros.h"
    #include "isac.h"
#endif
#ifdef WEBRTC_CODEC_ISACFX
    #include "acm_isac.h"
    #include "acm_isac_macros.h"
    #include "isacfix.h"
#endif
#ifdef WEBRTC_CODEC_PCM16
    #include "pcm16b.h"
    #include "acm_pcm16b.h"
#endif
#ifdef WEBRTC_CODEC_G722
    #include "acm_g722.h"
    #include "g722_interface.h"
#endif

namespace webrtc
{

#define TEMPORARY_BUFFER_SIZE 500

bool ACMCodecDB::_isInitiated = false;
WebRtc_Word16 ACMCodecDB::_noOfCodecs   = 0;
WebRtc_Word16 ACMCodecDB::_noNetEqDecoders   = 0;
WebRtc_Word16 ACMCodecDB::_noPayloads   = 0;

WebRtc_Word16 ACMCodecDB::isac        = -1;
WebRtc_Word16 ACMCodecDB::isacswb     = -1;
WebRtc_Word16 ACMCodecDB::pcm16b      = -1;
WebRtc_Word16 ACMCodecDB::pcm16bwb    = -1;
WebRtc_Word16 ACMCodecDB::pcm16bswb32 = -1;
WebRtc_Word16 ACMCodecDB::pcm16bswb48 = -1;
WebRtc_Word16 ACMCodecDB::pcmu        = -1;
WebRtc_Word16 ACMCodecDB::pcma        = -1;
WebRtc_Word16 ACMCodecDB::ilbc        = -1;
WebRtc_Word16 ACMCodecDB::gsmAMR      = -1;
WebRtc_Word16 ACMCodecDB::gsmAMRWB    = -1;
WebRtc_Word16 ACMCodecDB::g722        = -1;
WebRtc_Word16 ACMCodecDB::g722_1_32   = -1;
WebRtc_Word16 ACMCodecDB::g722_1_24   = -1;
WebRtc_Word16 ACMCodecDB::g722_1_16   = -1;
WebRtc_Word16 ACMCodecDB::g722_1C_48  = -1;
WebRtc_Word16 ACMCodecDB::g722_1C_32  = -1;
WebRtc_Word16 ACMCodecDB::g722_1C_24  = -1;
WebRtc_Word16 ACMCodecDB::g729        = -1;
WebRtc_Word16 ACMCodecDB::gsmfr       = -1;
WebRtc_Word16 ACMCodecDB::speex8      = -1;
WebRtc_Word16 ACMCodecDB::speex16     = -1;
WebRtc_Word16 ACMCodecDB::cnNB        = -1;
WebRtc_Word16 ACMCodecDB::cnWB        = -1;
WebRtc_Word16 ACMCodecDB::cnSWB       = -1;
WebRtc_Word16 ACMCodecDB::avt         = -1;
WebRtc_Word16 ACMCodecDB::red         = -1;

WebRtc_UWord8      ACMCodecDB::_nrOfAllowedPacSizes[MAX_NR_OF_CODECS];
WebRtc_UWord16     ACMCodecDB::_allowedPacSizesSmpl[MAX_NR_OF_CODECS][MAX_NR_OF_PACSIZES];
CodecInst          ACMCodecDB::_mycodecs[MAX_NR_OF_CODECS];
enum WebRtcNetEQDecoder ACMCodecDB::_netEqDecoders[MAX_NR_OF_CODECS];
WebRtc_Word8       ACMCodecDB::_versions[VERSION_SIZE];
WebRtc_UWord16     ACMCodecDB::_basicCodingBlockSmpl[MAX_NR_OF_CODECS];
WebRtc_UWord16     ACMCodecDB::_channelSupport[MAX_NR_OF_CODECS];
WebRtc_UWord32     ACMCodecDB::_versionStringSize = 0;

// We dynamically allocate some of the dynamic payload types to the defined codecs
// Note! There are a limited number of payload types. If more codecs are defined
// they will receive reserved fixed payload types (values 65-95).
static int kDynamicPayloadtypes[MAX_NR_OF_CODECS] = {
    105, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
    120, 121, 122, 123, 124, 125, 126,  95,  94,  93,  92,  91,  90,  89,
     88,  87,  86,  85,  84,  83,  82,  81,  80,  79,  78,  77,  76,  75,
     74,  73,  72,  71,  70,  69,  68,  67,  66,  65
};

WebRtc_Word16
ACMCodecDB::Codec(
    WebRtc_Word16 listnr,
    CodecInst*    codec_inst)
{
    // Error check to se that listnr is between 0 and (_noOfCodecs - 1)
    if ((listnr < 0) || (listnr >= _noOfCodecs))
    {
        return -1;
    }

    memcpy(codec_inst,&_mycodecs[listnr],sizeof(CodecInst));
    return 0;
}


WebRtc_Word16
ACMCodecDB::CodecNumber(
    const CodecInst* codecInst,
    WebRtc_Word16&   mirrorID,
    WebRtc_Word8*    errMessage,
    WebRtc_Word16    maxErrMsgLenByte)
{
    WebRtc_Word16 codecID = ACMCodecDB::CodecNumber(codecInst, mirrorID);
    if((codecID < 0) && (errMessage != NULL))
    {
        WebRtc_Word8 myErrMsg[1000];
        if (codecID == -10)
        {
            // Codec not supported
            sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, plname=%s is \
not a valid codec", codecInst->plname);
        }
        else if (codecID == -20)
        {
            // Sampling frequency doesn't match codec
            sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, plfreq=%d is \
not a valid frequency for the codec %s", codecInst->plfreq, codecInst->plname);
        }
        else if (codecID == -30)
        {
            // Wrong payload type for Comfort Noise
            sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, payload \
number %d is out of range for %s", codecInst->pltype, codecInst->plname);
        }
        else if (codecID == -40)
        {
            // Wrong payload type for RED
            sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, payload \
number %d is out of range for %s", codecInst->pltype, codecInst->plname);
        }
        else if (codecID == -50)
        {
            // Packet size is out of range for the codec
            sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, Packet \
size is out of range for %s", codecInst->plname);
        }
        else if (codecID == -60)
        {
            // Not a valid rate for the codec
           sprintf(myErrMsg,
                    "Call to ACMCodecDB::CodecNumber failed, rate=%d \
is not a valid rate for %s", codecInst->rate, codecInst->plname);
        }
        else
        {
            // Other error
            sprintf(myErrMsg,
                    "invalid codec parameters to be registered, \
ACMCodecDB::CodecNumber failed");
        }
        strncpy(errMessage, myErrMsg, maxErrMsgLenByte - 1);
        // make sure that the massage is null-terminated.
        errMessage[maxErrMsgLenByte - 1] = '\0';
    }
    return codecID;
}


WebRtc_Word16
ACMCodecDB::CodecNumber(
    const CodecInst* codec_inst,
    WebRtc_Word16&   mirrorID)
{
    WebRtc_Word16 codecNumber = -1;
    WebRtc_Word16 nameMatch = 0;

    // Find a matching payload name and frequency in the codec list
    // Need to check both since some codecs have several codec entries with
    // Different frequencies (like iSAC)
    for(WebRtc_Word16 i = 0; i < _noOfCodecs; i++)
    {
        if(STR_CASE_CMP(_mycodecs[i].plname, codec_inst->plname) == 0)
        {
            //We have found a matching codec name in the list
            nameMatch = 1;

            // Check if frequncy match
            if (codec_inst->plfreq == _mycodecs[i].plfreq)
            {
                codecNumber = i;
                break;
            }
        }
    }

    if(codecNumber == -1)
    {
        if (!nameMatch) {
            // Codec name doesn't match any codec in the list
            return -10;
        } else {
            // Error in payload frequency, doesn't match codec
            return -20;
        }
    }

    // Check the validity of payload type
    if(ValidPayloadType(codec_inst->pltype) < 0)
    {
        // Payload type out of range
        return -40;
    }

    // Comfort Noise is special case, packet-size & rate is not checked
    if(STR_CASE_CMP(_mycodecs[codecNumber].plname, "CN") == 0)
    {
        mirrorID = codecNumber;
        return codecNumber;
    }

    // RED is special case, packet-size & rate is not checked
    if(STR_CASE_CMP(_mycodecs[codecNumber].plname, "red") == 0)
    {
        mirrorID = codecNumber;
        return codecNumber;
    }

    // Check the validity of packet size
    if(_nrOfAllowedPacSizes[codecNumber] > 0)
    {
        // Check that the new packet size is in the valid range.
        bool pacSizeOK = false;
        for(WebRtc_Word32 i=0;i< _nrOfAllowedPacSizes[codecNumber];i++)
        {
            if(codec_inst->pacsize == _allowedPacSizesSmpl[codecNumber][i])
            {
                pacSizeOK = true;
                break;
            }
        }
        if(!pacSizeOK)
        {
            // Packet size is out of range
            return -50;
        }
    }
    if( codec_inst->pacsize < 1)
    {
        // Packet size is out of range
        return -50;
    }

    mirrorID = codecNumber;

    // Check the validity of rate
    if(STR_CASE_CMP("isac", codec_inst->plname) == 0)
    {
        if(IsISACRateValid(codec_inst->rate))
        {
            // Set mirrorID to iSAC WB which is only created
            // once to be used both for iSAC WB and SWB, because
            // they need to share struct
            mirrorID = ACMCodecDB::isac;
            return  codecNumber;
        }
        else
        {
            // Not a valid rate
            return -60;
        }
    }
    else if(STR_CASE_CMP("ilbc", codec_inst->plname) == 0)
    {
        return IsILBCRateValid(codec_inst->rate, codec_inst->pacsize) ? codecNumber : -60;
    }

    return IsRateValid(codecNumber, codec_inst->rate) ? codecNumber : -60;
}


WebRtc_Word16
ACMCodecDB::ReceiverCodecNumber(
    const CodecInst& codecInst,
    WebRtc_Word16&   mirrorID)
{
    WebRtc_Word16 codecNumber = -1;
    WebRtc_Word16 nameMatch = 0;

    // Find a matching payload name and frequency in the codec list
    // Need to check both since some codecs have several codec entries with
    // Different frequencies (like iSAC)
    for(WebRtc_Word16 i = 0; i < _noOfCodecs; i++)
    {
        if(STR_CASE_CMP(_mycodecs[i].plname, codecInst.plname) == 0)
        {
            //We have found a matching codec name in the list
            nameMatch = 1;

            // Check if frequency match
            if (codecInst.plfreq == _mycodecs[i].plfreq)
            {
                codecNumber = i;
                mirrorID = codecNumber;

                // Check if codec is iSAC, set mirrorID to iSAC WB
                // which is only created once to be used both for
                // iSAC WB and SWB, because they need to share struct
                if(STR_CASE_CMP(codecInst.plname, "ISAC") == 0)
                {
                    mirrorID = ACMCodecDB::isac;
                }
                break;
            }
        }
    }

    if(codecNumber == -1)
    {
        return codecNumber;
    }

    return codecNumber;
}


// Return number of codecs in the database
WebRtc_Word16
ACMCodecDB::NoOfCodecs()
{
    return _noOfCodecs;
}


// Return number of NetEQ decoders in the database.
// Note that the number is huigher than _moOfCodecs because some payload names
// are treated as different decoders in NetEQ, like iSAC wb and swb.
WebRtc_Word16
ACMCodecDB::NoNetEqDecoders()
{
    return _noNetEqDecoders;
}


// Return the codec sampling frequency for code number "listnr" in database
WebRtc_Word32
ACMCodecDB::CodecFreq(WebRtc_Word16 listnr)
{
    // Error check to se that listnr is between 0 and (_noOfCodecs - 1)
    if ( listnr < 0 || listnr >= _noOfCodecs)
        return -1;

    return _mycodecs[listnr].plfreq;
}

// Return the codecs basic coding block size in samples
WebRtc_Word16
ACMCodecDB::BasicCodingBlock(
    WebRtc_Word16 listNr)
{
    // Error check to se that listnr is between 0 and (_noOfCodecs - 1)
    if ( listNr < 0 || listNr >= _noOfCodecs)
        return -1;

    return _basicCodingBlockSmpl[listNr];
}

// Return the NetEQ decoder database
enum WebRtcNetEQDecoder*
ACMCodecDB::NetEqDecoders()
{
    return _netEqDecoders;
}

// All version numbers for the codecs in the data base are listed in text.
WebRtc_Word16
ACMCodecDB::CodecsVersion(
    WebRtc_Word8*   version,
    WebRtc_UWord32& remainingBufferInBytes,
    WebRtc_UWord32& position)
{
    WebRtc_UWord32 len = position;
    strncpy(&version[len], _versions, remainingBufferInBytes);
    position = (WebRtc_UWord32)strlen(version);
    remainingBufferInBytes -= (position - len);
    if(remainingBufferInBytes < _versionStringSize)
    {
        return -1;
    }
    return 0;
}

// Get mirror id. The Id is used for codecs sharing struct for settings that
// need different payload types.
WebRtc_Word16
ACMCodecDB::MirrorID(
    const WebRtc_Word16 codecID)
{
    if(STR_CASE_CMP(_mycodecs[codecID].plname, "isac") == 0)
    {
        return ACMCodecDB::isac;
    }
    else
    {
        return codecID;
    }
}



ACMGenericCodec*
ACMCodecDB::CreateCodecInstance(
    const CodecInst* codecInst)
{
    // All we have support for right now
    if(!STR_CASE_CMP(codecInst->plname, "ISAC"))
    {
#if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
        return new ACMISAC(isac);
#endif
    }
    else if(!STR_CASE_CMP(codecInst->plname, "PCMU"))
    {
        return new ACMPCMU(pcmu);
    }
    else if(!STR_CASE_CMP(codecInst->plname, "PCMA"))
    {
        return new ACMPCMA(pcma);
    }
    else if(!STR_CASE_CMP(codecInst->plname, "ILBC"))
    {
#ifdef WEBRTC_CODEC_ILBC
        return new ACMILBC(ilbc);
#endif
    }
    else if(!STR_CASE_CMP(codecInst->plname, "G722"))
    {
#ifdef WEBRTC_CODEC_G722
        return new ACMG722(g722);
#endif
    }
    else if(!STR_CASE_CMP(codecInst->plname, "CN"))
    {
        // We need to check sampling frequency
        // know what codec to create.
        WebRtc_Word16 codecID;
        switch(codecInst->plfreq)
        {
        case 8000:
            {
                codecID = ACMCodecDB::cnNB;
                break;
            }
        case 16000:
            {
                codecID = ACMCodecDB::cnWB;
                break;
            }
        case 32000:
            {
                codecID = ACMCodecDB::cnSWB;
                break;
            }
        default:
            return NULL;
        }
        return new ACMCNG(codecID);
    }
    else if(!STR_CASE_CMP(codecInst->plname, "L16"))
    {
#ifdef WEBRTC_CODEC_PCM16
        // For this codec we need to check sampling frequency
        // to know what codec to create.
        WebRtc_Word16 codecID;
        switch(codecInst->plfreq)
        {
        case 8000:
            {
                codecID = ACMCodecDB::pcm16b;
                break;
            }
        case 16000:
            {
                codecID = ACMCodecDB::pcm16bwb;
                break;
            }
        case 32000:
            {
                codecID = ACMCodecDB::pcm16bswb32;
                break;
            }
        default:
            return NULL;
        }
        return new ACMPCM16B(codecID);
#endif
    }
    else if(!STR_CASE_CMP(codecInst->plname, "telephone-event"))
    {
#ifdef WEBRTC_CODEC_AVT
        return new ACMDTMFPlayout(avt);
#endif
    }
    else if(!STR_CASE_CMP(codecInst->plname, "red"))
    {
#ifdef WEBRTC_CODEC_RED
        return new ACMRED(red);
#endif
    }
    return NULL;
}


//Here we build the complete database "_mycodecs" of our codecs
void
ACMCodecDB::initACMCodecDB()
{
    if(_isInitiated)
    {
        return;
    }
    else
    {
        _isInitiated = true;
    }
    WebRtc_Word8 versionNrBuff[TEMPORARY_BUFFER_SIZE];
    WebRtc_Word32 remainingSize = VERSION_SIZE;

    _versions[0] = '\0';

    // Init the stereo settings vector
    for (int i=0; i<MAX_NR_OF_CODECS; i++)
    {
        _channelSupport[i] = 1;
    }

#if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
    strcpy(_mycodecs[_noOfCodecs].plname,"ISAC");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = ISACWB_DEFAULT_RATE; // Default rate
    _mycodecs[_noOfCodecs].plfreq   = 16000;
    _mycodecs[_noOfCodecs].pltype   = 103;
    _mycodecs[_noOfCodecs].pacsize  = ISACWB_PAC_SIZE; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 2;
    _allowedPacSizesSmpl[_noOfCodecs][0] = ISACWB_PAC_SIZE;   // 480 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = ISACWB_PAC_SIZE*2;   // 960 sampels equals 60 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;

    isac=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderISAC;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    ACM_ISAC_VERSION(versionNrBuff);
    strncat(_versions, "ISAC\t\t", remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, versionNrBuff, remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, "\n", remainingSize);
#   if (defined(WEBRTC_CODEC_ISAC))
        strcpy(_mycodecs[_noOfCodecs].plname,"ISAC");
        _mycodecs[_noOfCodecs].channels = 1;
        _mycodecs[_noOfCodecs].rate     = ISACSWB_DEFAULT_RATE; // Default rate
        _mycodecs[_noOfCodecs].plfreq   = 32000;
        _mycodecs[_noOfCodecs].pltype   = 104;
        _mycodecs[_noOfCodecs].pacsize  = ISACSWB_PAC_SIZE; // Default packet size

        _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
        _allowedPacSizesSmpl[_noOfCodecs][0] = ISACSWB_PAC_SIZE;   // 960 sampels equals 60 ms
        _basicCodingBlockSmpl[_noOfCodecs]   = 0;

        isacswb = _noOfCodecs;
        _netEqDecoders[_noNetEqDecoders++] = kDecoderISACswb;
        _noOfCodecs++;
#   endif
#endif
#ifdef WEBRTC_CODEC_PCM16
    strcpy(_mycodecs[_noOfCodecs].plname,"L16");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 128000;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = kDynamicPayloadtypes[_noPayloads++];
    _mycodecs[_noOfCodecs].pacsize  = 80; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 4;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 80;  //  80 sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 160; // 160 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 240; // 240 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 320; // 320 sampels equals 40 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;
    _channelSupport[_noOfCodecs] = 2;

    pcm16b=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderPCM16B;
    _noOfCodecs++;


    strcpy(_mycodecs[_noOfCodecs].plname,"L16");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 256000;
    _mycodecs[_noOfCodecs].plfreq   = 16000;
    _mycodecs[_noOfCodecs].pltype   = kDynamicPayloadtypes[_noPayloads++];
    _mycodecs[_noOfCodecs].pacsize  = 160; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 4;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 160; // 160 sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 320; // 320 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 480; // 480 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 640; // 640 sampels equals 40 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;
    _channelSupport[_noOfCodecs] = 2;

    pcm16bwb=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderPCM16Bwb;
    _noOfCodecs++;

    strcpy(_mycodecs[_noOfCodecs].plname,"L16");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 512000;
    _mycodecs[_noOfCodecs].plfreq   = 32000;
    _mycodecs[_noOfCodecs].pltype   = kDynamicPayloadtypes[_noPayloads++];
    _mycodecs[_noOfCodecs].pacsize  = 320; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 2;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 320;  //  320 sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 640;  //  640 sampels equals 20 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;
    _channelSupport[_noOfCodecs] = 2;

    pcm16bswb32=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderPCM16Bswb32kHz;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, "L16\t\t1.0.0\n", remainingSize);
#endif
    strcpy(_mycodecs[_noOfCodecs].plname,"PCMU");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 64000;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = 0;
    _mycodecs[_noOfCodecs].pacsize  = 160; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 6;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 80;  // 80  sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 160; // 160 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 240; // 240 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 320; // 320 sampels equals 40 ms
    _allowedPacSizesSmpl[_noOfCodecs][4] = 400; // 400 sampels equals 50 ms
    _allowedPacSizesSmpl[_noOfCodecs][5] = 480; // 480 sampels equals 60 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;   /* 0 indicates all allowed
                                                packetsizes can be used as
                                                basic coding block   */
    _channelSupport[_noOfCodecs] = 2;

    pcmu=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderPCMu;
    _noOfCodecs++;

    strcpy(_mycodecs[_noOfCodecs].plname,"PCMA");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 64000;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = 8;
    _mycodecs[_noOfCodecs].pacsize  = 160; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 6;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 80;  // 80  sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 160; // 160 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 240; // 240 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 320; // 320 sampels equals 40 ms
    _allowedPacSizesSmpl[_noOfCodecs][4] = 400; // 400 sampels equals 50 ms
    _allowedPacSizesSmpl[_noOfCodecs][5] = 480; // 480 sampels equals 60 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;   /* 0 indicates all allowed
                                                 packetsizes can be used as
                                                 basic coding block       */
    _channelSupport[_noOfCodecs] = 2;

    pcma=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderPCMa;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    WebRtcG711_Version(versionNrBuff, TEMPORARY_BUFFER_SIZE);
    strncat(_versions, "G.711\t\t", remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, versionNrBuff, remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, "\n", remainingSize);

#ifdef WEBRTC_CODEC_ILBC
    strcpy(_mycodecs[_noOfCodecs].plname,"iLBC");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 13300;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = 102;
    _mycodecs[_noOfCodecs].pacsize  = 240; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 4;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 160; // 160 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 240; // 240 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 320; // 320 sampels equals 40 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 480; // 480 sampels equals 60 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;   /* 0 indicates all allowed
                                                 packetsizes can be used as
                                                 basic coding block       */

    ilbc=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderILBC;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    WebRtcIlbcfix_version(versionNrBuff);
    strncat(_versions, "ILBC\t\t", remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, versionNrBuff, remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, "\n", remainingSize);
#endif
#ifdef WEBRTC_CODEC_G722
    strcpy(_mycodecs[_noOfCodecs].plname,"G722");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 64000;
    _mycodecs[_noOfCodecs].plfreq   = 16000;
    _mycodecs[_noOfCodecs].pltype   = 9;
    _mycodecs[_noOfCodecs].pacsize  = 320; // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 6;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 160; // 160 sampels equals 10 ms
    _allowedPacSizesSmpl[_noOfCodecs][1] = 320; // 320 sampels equals 20 ms
    _allowedPacSizesSmpl[_noOfCodecs][2] = 480; // 480 sampels equals 30 ms
    _allowedPacSizesSmpl[_noOfCodecs][3] = 640; // 640 sampels equals 40 ms
    _allowedPacSizesSmpl[_noOfCodecs][4] = 800; // 480 sampels equals 50 ms
    _allowedPacSizesSmpl[_noOfCodecs][5] = 960; // 640 sampels equals 60 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;
    _channelSupport[_noOfCodecs] = 2;

    g722=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderG722;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    WebRtcG722_Version(versionNrBuff, TEMPORARY_BUFFER_SIZE);
    strncat(_versions, "G.722\t\t", remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, versionNrBuff, remainingSize);

#endif

    // Comfort Noise is always included in the build, no #ifdef needed
    strcpy(_mycodecs[_noOfCodecs].plname,"CN");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 0;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = 13;
    _mycodecs[_noOfCodecs].pacsize  = 240;   // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 240; // 240 samples equals 30 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 240;

     cnNB=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderCNG;
    _noOfCodecs++;

     strcpy(_mycodecs[_noOfCodecs].plname,"CN");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 0;
    _mycodecs[_noOfCodecs].plfreq   = 16000;
    _mycodecs[_noOfCodecs].pltype   = 98;
    _mycodecs[_noOfCodecs].pacsize  = 480;   // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 480; // 480 samples equals 30 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 480;

     cnWB=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderCNG;
    _noOfCodecs++;

     strcpy(_mycodecs[_noOfCodecs].plname,"CN");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 0;
    _mycodecs[_noOfCodecs].plfreq   = 32000;
    _mycodecs[_noOfCodecs].pltype   = 99;
    _mycodecs[_noOfCodecs].pacsize  = 960;   // Default packet size

    _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 960; // 960 samples equals 30 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 960;

     cnSWB=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderCNG;
    _noOfCodecs++;

    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    WebRtcCng_Version(versionNrBuff);
    strncat(_versions, "CNG\t\t", remainingSize);
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, versionNrBuff, remainingSize);

#ifdef WEBRTC_CODEC_AVT
    strcpy(_mycodecs[_noOfCodecs].plname,"telephone-event");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].rate     = 0;
    _mycodecs[_noOfCodecs].pltype   = 106;
    _mycodecs[_noOfCodecs].pacsize  = 240;    // Default packet size 240ms

    _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 240; // 240 samples equals 30 ms
    _basicCodingBlockSmpl[_noOfCodecs]   = 240;

    avt=_noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderAVT;
    _noOfCodecs++;

    // Currently tone generation doesn't have a getVersion-function
    remainingSize = (WebRtc_Word32)(VERSION_SIZE - strlen(_versions));
    strncat(_versions, "Tone Generation\t1.0.0\n", remainingSize);
#endif
#ifdef WEBRTC_CODEC_RED
    strcpy(_mycodecs[_noOfCodecs].plname,"red");
    _mycodecs[_noOfCodecs].channels = 1;
    _mycodecs[_noOfCodecs].rate     = 0;
    _mycodecs[_noOfCodecs].plfreq   = 8000;
    _mycodecs[_noOfCodecs].pltype   = 127;
    _mycodecs[_noOfCodecs].pacsize  = 0;

    _nrOfAllowedPacSizes[_noOfCodecs]    = 1;
    _allowedPacSizesSmpl[_noOfCodecs][0] = 0;
    _basicCodingBlockSmpl[_noOfCodecs]   = 0;

    red = _noOfCodecs;
    _netEqDecoders[_noNetEqDecoders++] = kDecoderRED;
    _noOfCodecs++;
#endif


    _versionStringSize = (WebRtc_UWord32)strlen(_versions);
}


// Check if the bitrate is valid for the codec
bool
ACMCodecDB::IsRateValid(
    const WebRtc_Word16 listNr,
    const WebRtc_Word32 rate)
{
    if(_mycodecs[listNr].rate == rate)
    {
        return true;
    }
    else
    {
        return false;
    }
}


// Check if the bitrate is valid for iSAC
bool
ACMCodecDB::IsISACRateValid(
#if (!defined(WEBRTC_CODEC_ISAC) && !defined(WEBRTC_CODEC_ISACFX))
    const WebRtc_Word32 /* rate */)
{
    return false;
#else
    const WebRtc_Word32 rate)
{
    if((rate == -1) ||
        ((rate <= 56000) && (rate >= 10000)))
    {
        return true;
    }
    else
    {
        return false;
    }
#endif
}

// Check if the bitrate is valid for iLBC
bool
ACMCodecDB::IsILBCRateValid(
#ifndef WEBRTC_CODEC_ILBC
    const WebRtc_Word32 /* rate             */,
    const WebRtc_Word16 /* frameSizeSamples */)
{
    return false;
#else
    const WebRtc_Word32 rate,
    const WebRtc_Word16 frameSizeSamples)
{
    if(((frameSizeSamples == 240) || (frameSizeSamples == 480)) &&
        (rate == 13300))
    {
        return true;
    }
    else if(((frameSizeSamples == 160) || (frameSizeSamples == 320)) &&
        (rate == 15200))
    {
        return true;
    }
    else
    {
        return false;
    }
#endif
}

// Check if the payload type is valid
WebRtc_Word16
ACMCodecDB::ValidPayloadType(
    const int    payloadType)
{
    if((payloadType < 0) || (payloadType > 127))
    {
        return -1;
    }
    return 0;
}

} // namespace webrtc