/* *  LAME MP3 encoder for DirectShow *  LAME encoder wrapper * *  Copyright (c) 2000-2005 Marie Orlova, Peter Gubanov, Vitaly Ivanov, Elecard Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */#include <streams.h>#include "Encoder.h"//////////////////////////////////////////////////////////////////////// Construction/Destruction//////////////////////////////////////////////////////////////////////CEncoder::CEncoder() :    m_bInpuTypeSet(FALSE),    m_bOutpuTypeSet(FALSE),    m_bFinished(FALSE),    m_outOffset(0),    m_outReadOffset(0),    m_frameCount(0),    pgf(NULL){    m_outFrameBuf = new unsigned char[OUT_BUFFER_SIZE];}CEncoder::~CEncoder(){    Close();    if (m_outFrameBuf)        delete [] m_outFrameBuf;}//////////////////////////////////////////////////////////////////////// SetInputType - check if given input type is supported//////////////////////////////////////////////////////////////////////HRESULT CEncoder::SetInputType(LPWAVEFORMATEX lpwfex, bool bJustCheck){    CAutoLock l(&m_lock);    if (lpwfex->wFormatTag == WAVE_FORMAT_PCM)    {        if (lpwfex->nChannels == 1 || lpwfex->nChannels == 2)        {            if (lpwfex->nSamplesPerSec  == 48000 ||                lpwfex->nSamplesPerSec  == 44100 ||                lpwfex->nSamplesPerSec  == 32000 ||                lpwfex->nSamplesPerSec  == 24000 ||                lpwfex->nSamplesPerSec  == 22050 ||                lpwfex->nSamplesPerSec  == 16000 ||                lpwfex->nSamplesPerSec  == 12000 ||                lpwfex->nSamplesPerSec  == 11025 ||                lpwfex->nSamplesPerSec  ==  8000)            {                if (lpwfex->wBitsPerSample == 16)                {                    if (!bJustCheck)                    {                        memcpy(&m_wfex, lpwfex, sizeof(WAVEFORMATEX));                        m_bInpuTypeSet = true;                    }                    return S_OK;                }            }        }    }    if (!bJustCheck)        m_bInpuTypeSet = false;    return E_INVALIDARG;}//////////////////////////////////////////////////////////////////////// SetOutputType - try to initialize encoder with given output type//////////////////////////////////////////////////////////////////////HRESULT CEncoder::SetOutputType(MPEG_ENCODER_CONFIG &mabsi){    CAutoLock l(&m_lock);    m_mabsi = mabsi;    m_bOutpuTypeSet = true;    return S_OK;}//////////////////////////////////////////////////////////////////////// SetDefaultOutputType - sets default MPEG audio properties according// to input type//////////////////////////////////////////////////////////////////////HRESULT CEncoder::SetDefaultOutputType(LPWAVEFORMATEX lpwfex){    CAutoLock l(&m_lock);    if(lpwfex->nChannels == 1 || m_mabsi.bForceMono)        m_mabsi.ChMode = MONO;    if((lpwfex->nSamplesPerSec < m_mabsi.dwSampleRate) || (lpwfex->nSamplesPerSec % m_mabsi.dwSampleRate != 0))        m_mabsi.dwSampleRate = lpwfex->nSamplesPerSec;    return S_OK;}//////////////////////////////////////////////////////////////////////// Init - initialized or reiniyialized encoder SDK with given input // and output settings//////////////////////////////////////////////////////////////////////HRESULT CEncoder::Init(){    CAutoLock l(&m_lock);    m_outOffset     = 0;    m_outReadOffset = 0;    m_bFinished     = FALSE;    m_frameCount    = 0;    if (!pgf)    {        if (!m_bInpuTypeSet || !m_bOutpuTypeSet)            return E_UNEXPECTED;        // Init Lame library        // note: newer, safer interface which doesn't         // allow or require direct access to 'gf' struct is being written        // see the file 'API' included with LAME.        if (pgf = lame_init())        {            pgf->num_channels = m_wfex.nChannels;            pgf->in_samplerate = m_wfex.nSamplesPerSec;            pgf->out_samplerate = m_mabsi.dwSampleRate;            if ((pgf->out_samplerate >= 32000) && (m_mabsi.dwBitrate < 32))                pgf->brate = 32;            else                pgf->brate = m_mabsi.dwBitrate;            pgf->VBR = m_mabsi.vmVariable;            pgf->VBR_min_bitrate_kbps = m_mabsi.dwVariableMin;            pgf->VBR_max_bitrate_kbps = m_mabsi.dwVariableMax;            pgf->copyright = m_mabsi.bCopyright;            pgf->original = m_mabsi.bOriginal;            pgf->error_protection = m_mabsi.bCRCProtect;            pgf->bWriteVbrTag = m_mabsi.dwXingTag;            pgf->strict_ISO = m_mabsi.dwStrictISO;            pgf->VBR_hard_min = m_mabsi.dwEnforceVBRmin;            if (pgf->num_channels == 2 && !m_mabsi.bForceMono)            {                int act_br = pgf->VBR ? pgf->VBR_min_bitrate_kbps + pgf->VBR_max_bitrate_kbps / 2 : pgf->brate;                // Disabled. It's for user's consideration now                //int rel = pgf->out_samplerate / (act_br + 1);                //pgf->mode = rel < 200 ? m_mabsi.ChMode : JOINT_STEREO;                pgf->mode = m_mabsi.ChMode;            }            else                pgf->mode = MONO;            if (pgf->mode == JOINT_STEREO)                pgf->force_ms = m_mabsi.dwForceMS;            else                pgf->force_ms = 0;            pgf->mode_fixed = m_mabsi.dwModeFixed;            if (m_mabsi.dwVoiceMode != 0)            {                pgf->lowpassfreq = 12000;                pgf->VBR_max_bitrate_kbps = 160;            }            if (m_mabsi.dwKeepAllFreq != 0)            {                pgf->lowpassfreq = -1;                pgf->highpassfreq = -1;            }            pgf->quality = m_mabsi.dwQuality;            pgf->VBR_q = m_mabsi.dwVBRq;            lame_init_params(pgf);            // encoder delay compensation            {                short * start_padd = (short *)calloc(48, pgf->num_channels * sizeof(short));                if (pgf->num_channels == 2)                    lame_encode_buffer_interleaved(pgf, start_padd, 48, m_outFrameBuf, OUT_BUFFER_SIZE);                else                    lame_encode_buffer(pgf, start_padd, start_padd, 48, m_outFrameBuf, OUT_BUFFER_SIZE);                free(start_padd);            }            return S_OK;        }        return E_FAIL;    }    return S_OK;}//////////////////////////////////////////////////////////////////////// Close - closes encoder//////////////////////////////////////////////////////////////////////HRESULT CEncoder::Close(){    CAutoLock l(&m_lock);    if (pgf)    {        lame_close(pgf);        pgf = NULL;    }    return S_OK;}//////////////////////////////////////////////////////////////////////// Encode - encodes data placed on pdata and returns// the number of processed bytes//////////////////////////////////////////////////////////////////////int CEncoder::Encode(const short * pdata, int data_size){    CAutoLock l(&m_lock);    if (!pgf || !m_outFrameBuf || !pdata || data_size < 0 || (data_size & (sizeof(short) - 1)))        return -1;    // some data left in the buffer, shift to start    if (m_outReadOffset > 0)    {        if (m_outOffset > m_outReadOffset)            memmove(m_outFrameBuf, m_outFrameBuf + m_outReadOffset, m_outOffset - m_outReadOffset);        m_outOffset -= m_outReadOffset;    }    m_outReadOffset = 0;    m_bFinished = FALSE;    int bytes_processed = 0;    while (1)    {        int nsamples = (data_size - bytes_processed) / (sizeof(short) * pgf->num_channels);        if (nsamples <= 0)            break;        if (nsamples > 1152)            nsamples = 1152;        if (m_outOffset >= OUT_BUFFER_MAX)            break;        int out_bytes = 0;        if (pgf->num_channels == 2)            out_bytes = lame_encode_buffer_interleaved(                                            pgf,                                            (short *)(pdata + (bytes_processed / sizeof(short))),                                            nsamples,                                            m_outFrameBuf + m_outOffset,                                            OUT_BUFFER_SIZE - m_outOffset);        else            out_bytes = lame_encode_buffer(                                            pgf,                                            pdata + (bytes_processed / sizeof(short)),                                            pdata + (bytes_processed / sizeof(short)),                                            nsamples,                                            m_outFrameBuf + m_outOffset,                                            OUT_BUFFER_SIZE - m_outOffset);        if (out_bytes < 0)            return -1;        m_outOffset     += out_bytes;        bytes_processed += nsamples * pgf->num_channels * sizeof(short);    }    return bytes_processed;}//// Finsh - flush the buffered samples//HRESULT CEncoder::Finish(){    CAutoLock l(&m_lock);    if (!pgf || !m_outFrameBuf || (m_outOffset >= OUT_BUFFER_MAX))        return E_FAIL;    m_outOffset += lame_encode_flush(pgf, m_outFrameBuf + m_outOffset, OUT_BUFFER_SIZE - m_outOffset);    m_bFinished = TRUE;    return S_OK;}int getFrameLength(const unsigned char * pdata){    if (!pdata || pdata[0] != 0xff || (pdata[1] & 0xe0) != 0xe0)        return -1;    const int sample_rate_tab[4][4] =    {        {11025,12000,8000,1},        {1,1,1,1},        {22050,24000,16000,1},        {44100,48000,32000,1}    };#define MPEG_VERSION_RESERVED   1#define MPEG_VERSION_1          3#define LAYER_III               1#define BITRATE_FREE            0#define BITRATE_RESERVED        15#define SRATE_RESERVED          3#define EMPHASIS_RESERVED       2    int version_id      = (pdata[1] & 0x18) >> 3;    int layer           = (pdata[1] & 0x06) >> 1;    int bitrate_id      = (pdata[2] & 0xF0) >> 4;    int sample_rate_id  = (pdata[2] & 0x0C) >> 2;    int padding         = (pdata[2] & 0x02) >> 1;    int emphasis        =  pdata[3] & 0x03;    if (version_id      != MPEG_VERSION_RESERVED &&        layer           == LAYER_III &&        bitrate_id      != BITRATE_FREE &&        bitrate_id      != BITRATE_RESERVED &&        sample_rate_id  != SRATE_RESERVED &&        emphasis        != EMPHASIS_RESERVED)    {        int spf         = (version_id == MPEG_VERSION_1) ? 1152 : 576;        int sample_rate = sample_rate_tab[version_id][sample_rate_id];        int bitrate     = dwBitRateValue[version_id != MPEG_VERSION_1][bitrate_id - 1] * 1000;        return (bitrate * spf) / (8 * sample_rate) + padding;    }    return -1;}int CEncoder::GetFrame(const unsigned char ** pframe){    if (!pgf || !m_outFrameBuf || !pframe)        return -1;    while ((m_outOffset - m_outReadOffset) > 4)    {        int frame_length = getFrameLength(m_outFrameBuf + m_outReadOffset);        if (frame_length < 0)        {            m_outReadOffset++;        }        else if (frame_length <= (m_outOffset - m_outReadOffset))        {            *pframe = m_outFrameBuf + m_outReadOffset;            m_outReadOffset += frame_length;            m_frameCount++;            // don't deliver the first and the last frames            if (m_frameCount != 1 && !(m_bFinished && (m_outOffset - m_outReadOffset) < 5))                return frame_length;        }        else            break;    }    return 0;}