Continue.

AudioEngine header file:
#ifndef _AUDIOENGINE_H_
#define _AUDIOENGINE_H_

#include “mysocket.h”
#include “portaudio.h”
#include “san_speex.h”
#include <qwidget.h>

#define SAMPLE_RATE  16000
#define FRAMES_PER_BUFFER 320
#define PA_SAMPLE_TYPE  paInt16
typedef short SAMPLE;
#define SAMPLE_SILENCE  (0)
#define NUM_CHANNELS    1
class AudioEngine;
typedef struct
{
    SanSpeexEnc     speexenc;
    SAMPLE          recordbuffer[FRAMES_PER_BUFFER * NUM_CHANNELS];
    char            encodedBufPlus8[FRAMES_PER_BUFFER * NUM_CHANNELS * 2 ];
    SanSpeexDec     speexdec;
    SAMPLE          playbackbuffer[FRAMES_PER_BUFFER * NUM_CHANNELS];
    AudioEngine    *obj;
} paTestData;
//============================================
class AudioEngine : public QWidget
{
    Q_OBJECT
public:
    AudioEngine();
    virtual ~AudioEngine();

    void recvPlaybackDataIn(const QByteArray& ba);
    void setSelfLoop(bool flag);
    bool isSelfLoop() const { return m_isSelfLoop; }
protected:
    virtual void closeEvent(QCloseEvent *);

private slots:
    void slotReceivedData(const QByteArray&);
    void slotReceivedHandshake(const QString& hisId);

private:
    static int s_recordCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData);
    static int s_playCallback(const void *inputBuffer, void *outputBuffer,
                              unsigned long framesPerBuffer,
                              const PaStreamCallbackTimeInfo* timeInfo,
                              PaStreamCallbackFlags statusFlags,
                              void *userData);
    static int s_loopCallback(const void *inputBuffer, void *outputBuffer,
                              unsigned long framesPerBuffer,
                              const PaStreamCallbackTimeInfo* timeInfo,
                              PaStreamCallbackFlags statusFlags,
                              void *userData);

    bool initPa();
    bool unInitPa();
    bool startPaRecorder(int id);
    bool startPaPlayback(int id);
    bool stopPaRecorder();
    bool stopPaPlayback();
    bool startPaRecorderPlaybackLoop(int inputId, int outputId);
    bool stopPaRecorderPlaybackLoop();

    void sendRecordDataOut(char *buf, int len);

private:
    MyServerSocket    *m_serverSocket;
    QString            m_recorderId;
    QString            m_playbackId;

    PaStream          *m_streamIn, *m_streamOut;
    PaError            m_errIn, m_errOut;
    int                m_inputId, m_outputId;

    paTestData         m_data;
    bool               m_isSelfLoop;
};

#endif // _AUDIOENGINE_H_

 AudioEngine source file:

#include “audioengine.h”
#include <qapplication.h>
#include <windows.h>
//#include <mmddk.h>

//===================================
AudioEngine::AudioEngine()
            :QWidget(),
             m_serverSocket(0),
             m_recorderId(QString::null),
             m_playbackId(QString::null),
             m_streamIn(0),
             m_streamOut(0),
             m_errIn(paNoError),
             m_errOut(paNoError),
             m_inputId(-1),
             m_outputId(-1),
             m_isSelfLoop(true)
{
    qDebug(“AE ctor”);
    m_serverSocket = new MyServerSocket();
    connect(m_serverSocket, SIGNAL(fireReceivedData(const QByteArray&)),
                            SLOT(slotReceivedData(const QByteArray&)));
    connect(m_serverSocket, SIGNAL(fireReceivedHandshake(const QString&)),
                            SLOT(slotReceivedHandshake(const QString&)));
    qDebug(“m_serverSocket port = %d”, m_serverSocket->port());

    resize(100, 100);
    move(0, 0);
    hide();

    m_data.obj = this;
    m_data.speexdec.setSanSpeexEnc(&m_data.speexenc);
    initPa();
}

AudioEngine::~AudioEngine()
{
    qDebug(“AE dtor”);
    delete m_serverSocket;
    m_serverSocket = 0;
    unInitPa();
}

void AudioEngine::closeEvent(QCloseEvent *)
{
    qDebug(“AE::closeEvent”);
    qApp->exit(0);
}

void AudioEngine::slotReceivedData(const QByteArray& ba)
{
    qDebug(“AE::slotRecvData = %d”, ba.size());
    const char *data = ba.data();
    if (ba.size() >= 4 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’)
    {
        char cmd = data[3];
        switch (cmd)
        {
        case ‘1′: //return device list;   dev1\ndev2\n…
            {
                QString devList(ba);
                devList = devList.mid(4);
                qDebug(“1. DevList = ” + devList);
            }
            break;
        case ‘2′: //set recorder device;  devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“2. RecorderDevice = ” + devName);
                m_inputId = devName.toInt();
            }
            break;
        case ‘3′: //set playback device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“3. PlaybackDevice = ” + devName);
                m_outputId = devName.toInt();
            }
            break;
        case ‘4′: //start recorder
            qDebug(“4. Start Recording”);
            if (!m_isSelfLoop)
            {
                if (m_inputId != -1 && m_streamIn == 0)
                    startPaRecorder(m_inputId);
            }
            else
            {
                if (m_inputId != -1 && m_outputId != -1 && m_streamIn == 0)
                    startPaRecorderPlaybackLoop(m_inputId, m_outputId);
            }
            break;
        case ‘5′: //start playback
            qDebug(“5. Start Playback”);
            if (!m_isSelfLoop)
            {
                if (m_outputId != -1 && m_streamOut == 0)
                    startPaPlayback(m_outputId);
            }
            else
            {
                if (m_inputId != -1 && m_outputId != -1 && m_streamIn == 0)
                    startPaRecorderPlaybackLoop(m_inputId, m_outputId);
            }
            break;
        case ‘6′: //stop recorder
            qDebug(“6. Stop Recording”);
            if (!m_isSelfLoop)
                stopPaRecorder();
            else
                stopPaRecorderPlaybackLoop();
            break;
        case ‘7′: //stop playback
            qDebug(“7. Stop Playback”);
            if (!m_isSelfLoop)
                stopPaPlayback();
            else
                stopPaRecorderPlaybackLoop();
            break;
        case ‘Q’: //totally exit
            qDebug(“Q. Quit”);
            if (m_serverSocket)
                m_serverSocket->stop();
            show();
            break;
        default:
            break;
        }//switch()
    }//”cmd”
    else //binary
    {
    }//binary
}//slotReceivedData()

void AudioEngine::slotReceivedHandshake(const QString& hisId)
{
    qDebug(“AE::slotRecvHandshake = ” + hisId);
    if (hisId == “recorder”)
        m_recorderId = hisId;
    else if (hisId == “playback”)
        m_playbackId = hisId;
}//slotReceivedHandshake()

int AudioEngine::s_recordCallback(const void *inputBuffer, void *outputBuffer,
                                  unsigned long framesPerBuffer,
                                  const PaStreamCallbackTimeInfo* timeInfo,
                                  PaStreamCallbackFlags statusFlags,
                                  void *userData)
{
    paTestData *data = (paTestData*)userData;
    const SAMPLE *rptr = (const SAMPLE*)inputBuffer;
    SAMPLE *wptr = data->recordbuffer;
    long framesToCalc;
    framesToCalc = framesPerBuffer;
    long i;
    int finished = paContinue;
    bool isSelfLoop = data->obj->isSelfLoop();
   
    (void) outputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

    if( inputBuffer == NULL )
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = SAMPLE_SILENCE;
            if (NUM_CHANNELS == 2)
                *wptr++ = SAMPLE_SILENCE;
        }
    }
    else
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = *rptr++;
            if (NUM_CHANNELS == 2)
                *wptr++ = *rptr++;
        }
    }

    int encSizePlus8 = data->speexenc.encode(data->recordbuffer, data->encodedBufPlus8);
    if (encSizePlus8 > 0)
    {
        int encSizePlus4 = ((int *)data->encodedBufPlus8)[0];

        //if (!isSelfLoop)
        {
            //send out encodedBufPlus8 to spydonk
            data->obj->sendRecordDataOut(data->encodedBufPlus8, encSizePlus8);
        }

        /*
        if (isSelfLoop)
        {
            //when seedonk receiving some audio buf from server, call following line
            data->speexdec.put(data->encodedBufPlus8+4, encSizePlus4);
        }
        */
    }

    return finished;
}//s_recordCallback()

int AudioEngine::s_playCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData)
{
    paTestData *data = (paTestData*)userData;
    SAMPLE *rptr = data->playbackbuffer;
    SAMPLE *wptr = (SAMPLE*)outputBuffer;
    int finished = paContinue;
    unsigned int framesLeft = 0;
    int i;
    bool isSelfLoop = data->obj->isSelfLoop();

    data->speexdec.get(rptr);
    framesLeft = framesPerBuffer;

    (void) inputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

    for( i=0; i<framesPerBuffer; i++ )
    {
        *wptr++ = *rptr++;
        if (NUM_CHANNELS == 2)
            *wptr++ = *rptr++;
    }

    rptr = data->playbackbuffer;
    data->speexdec.afterPlayback(rptr, true);

    return finished;
}//s_playCallback()

int AudioEngine::s_loopCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData)
{
    paTestData *data = (paTestData*)userData;
    const SAMPLE *rptr = (const SAMPLE*)inputBuffer;
    SAMPLE *wptr = (SAMPLE*)outputBuffer;
    SAMPLE *prevPlayPtr = data->playbackbuffer;
    long framesToCalc;
    framesToCalc = framesPerBuffer;
    long i;
    int finished = paContinue;
   
    (void) outputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

    //data->speexenc.playbackEcho(prevPlayPtr, true);

    if( inputBuffer == NULL )
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = SAMPLE_SILENCE;
            //*prevPlayPtr++ = SAMPLE_SILENCE;
            if (NUM_CHANNELS == 2)
            {
                *wptr++ = SAMPLE_SILENCE;
                //*prevPlayPtr++ = SAMPLE_SILENCE;
            }
        }
        return 0;
    }
    else
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = *rptr;
            //*prevPlayPtr++ = *rptr;
            rptr++;
            if (NUM_CHANNELS == 2)
            {
                *wptr++ = *rptr;
                //*prevPlayPtr++ = *rptr;
                rptr++;
            }
        }
    }

    //data->speexenc.captureEcho(wptr);
    data->speexenc.captureEcho(wptr, prevPlayPtr);
    for (i=0; i<framesToCalc; i++)
    {
        *prevPlayPtr++ = *wptr++;
    }

    return finished;
}//s_loopCallback()
bool AudioEngine::initPa()
{
    PaError err = Pa_Initialize();
    if (err == paNoError)
    {
        int numDevices = Pa_GetDeviceCount();
        int inputId, outputId;
        int prevHostApi = -1;
        for(int id=0; id<numDevices; id++)            /* Iterate through all devices. */
        {
            const PaDeviceInfo *pdi = Pa_GetDeviceInfo(id);
            if (prevHostApi != pdi->hostApi)
            {
                const PaHostApiInfo *info = Pa_GetHostApiInfo(pdi->hostApi);
                qDebug(“=== HostApi, %d, type=%d, name=%s ====”, pdi->hostApi, info->type, info->name);
                qDebug(“=== def I=%d, defO=%d ====”, info->defaultInputDevice, info->defaultOutputDevice);

                prevHostApi = pdi->hostApi;

            }
            qDebug(“[%d]=[%s], IChs=%d, OChs=%d”,
                               id, pdi->name,
                               pdi->maxInputChannels,
                               pdi->maxOutputChannels);

//#define DRV_RESERVED           0×0800
//#define DRV_QUERYDEVICEINTERFACE     (DRV_RESERVED + 12)
//#define DRV_QUERYDEVICEINTERFACESIZE (DRV_RESERVED + 13)

            /*
            if (pdi->maxInputChannels > 0)
            {
                DWORD pathSize = 0;
                if (waveInMessage((HWAVEIN)id, 0×0800+13,
                                   (DWORD_PTR)&pathSize, 0) != MMSYSERR_NOERROR)
                {
                    qDebug(“**** pathSize = %d”, pathSize);
                    char *path = new char[pathSize];
                    memset(path, 0, pathSize);
                    if (waveInMessage((HWAVEIN)id, 0×0800+12,
                                       (DWORD_PTR)path, sizeof(path)) != MMSYSERR_NOERROR)
                    {
                        qDebug(“**** path = %s”, path);
                    }
                    delete [] path;
                }
                else
                    qDebug(“**** ERROR %d”, id);
            }
            */
        }
    }
    qDebug(“======================================”);
    return (err == paNoError);
}

bool AudioEngine::unInitPa()
{
    if (m_streamIn)
        Pa_CloseStream(m_streamIn);
    m_streamIn = 0;
    if (m_streamOut)
        Pa_CloseStream(m_streamOut);
    m_streamOut = 0;

    Pa_Terminate();
    return true;
}

bool AudioEngine::startPaRecorder(int inputId)
{
    PaStreamParameters  inputParameters;

    inputParameters.device = inputId;
    inputParameters.channelCount = NUM_CHANNELS;
    inputParameters.sampleFormat = PA_SAMPLE_TYPE;
    inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputId)->defaultLowInputLatency;
    inputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Input Device = [%s], latency = %f”, Pa_GetDeviceInfo(inputId)->name, inputParameters.suggestedLatency);

    /* Record some audio. ——————————————– */
    m_errIn = Pa_OpenStream(&m_streamIn,
                            &inputParameters,
                            NULL,                  /* &outputParameters, */
                            SAMPLE_RATE,
                            FRAMES_PER_BUFFER*NUM_CHANNELS,
                            paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                            AudioEngine::s_recordCallback,
                            &m_data);
    if(m_errIn != paNoError)
        return false;

    m_errIn = Pa_StartStream(m_streamIn);
    if(m_errIn != paNoError)
        return false;
    qDebug(“Now recording!!”);
    return true;
}//startPaRecorder()

bool AudioEngine::startPaPlayback(int outputId)
{
    PaStreamParameters  outputParameters;

    outputParameters.device = outputId;
    outputParameters.channelCount = NUM_CHANNELS;
    outputParameters.sampleFormat =  PA_SAMPLE_TYPE;
    outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputId)->defaultLowOutputLatency;
    outputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Output Device = [%s], latency = %f”, Pa_GetDeviceInfo(outputId)->name, outputParameters.suggestedLatency);

    qDebug(“Begin playback.”);
    m_errOut = Pa_OpenStream(&m_streamOut,
                             NULL, /* no input */
                             &outputParameters,
                             SAMPLE_RATE,
                             FRAMES_PER_BUFFER*NUM_CHANNELS,
                             paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                             AudioEngine::s_playCallback,
                             &m_data);
    if(m_errOut != paNoError)
        return false;

    m_errOut = Pa_StartStream(m_streamOut);
    if(m_errOut != paNoError )
        return false;
    return true;
}//startPaPlayback()

bool AudioEngine::startPaRecorderPlaybackLoop(int inputId, int outputId)
{
    if (m_streamIn != 0) //already started
        return true;

    PaStreamParameters  inputParameters;
    PaStreamParameters  outputParameters;

    inputParameters.device = inputId;
    inputParameters.channelCount = NUM_CHANNELS;
    inputParameters.sampleFormat = PA_SAMPLE_TYPE;
    inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputId)->defaultLowInputLatency;
    inputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Input Device = [%s], latency = %f”, Pa_GetDeviceInfo(inputId)->name, inputParameters.suggestedLatency);
    outputParameters.device = outputId;
    outputParameters.channelCount = NUM_CHANNELS;
    outputParameters.sampleFormat =  PA_SAMPLE_TYPE;
    outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputId)->defaultLowOutputLatency;
    outputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Output Device = [%s], latency = %f”, Pa_GetDeviceInfo(outputId)->name, outputParameters.suggestedLatency);

    /* RecordPlayback Loop some audio. ——————————————– */
    m_errIn = Pa_OpenStream(&m_streamIn,
                            &inputParameters,
                            &outputParameters,
                            SAMPLE_RATE,
                            FRAMES_PER_BUFFER*NUM_CHANNELS,
                            paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                            AudioEngine::s_loopCallback,
                            &m_data);
    if(m_errIn != paNoError)
        return false;

    m_errIn = Pa_StartStream(m_streamIn);
    if(m_errIn != paNoError)
        return false;
    qDebug(“Now looping!!”);
    return true;
}//startPaRecorderPlaybackLoop()

bool AudioEngine::stopPaRecorder()
{
    if (m_streamIn)
        Pa_CloseStream(m_streamIn);
    m_streamIn = 0;
    return true;
}//stopPaRecorder()

bool AudioEngine::stopPaPlayback()
{
    if (m_streamOut)
        Pa_CloseStream(m_streamOut);
    m_streamOut = 0;
    return true;
}//stopPaPlayback()

bool AudioEngine::stopPaRecorderPlaybackLoop()
{
    return stopPaRecorder();
}//stopPaRecorderPlaybackLoop()

void AudioEngine::sendRecordDataOut(char *buf, int len)
{
    if (m_isSelfLoop)
        return;

    if (!m_recorderId.isNull() && m_serverSocket)
    {
        QByteArray ba;
        ba.setRawData(buf, len);
        m_serverSocket->send(ba, m_recorderId);
        ba.resetRawData(buf, len);
    }
}//sendRecordDataOut()

void AudioEngine::recvPlaybackDataIn(const QByteArray& ba)
{
    if (m_isSelfLoop)
        return;

    //buffer:
    //  encodedBufSize + 4 | timestamp | encodedBuf
    // ——————–+———–+——————–
    //  4                  |  4        | encodedBufSize – 4
    int len = 0;
    if (!m_playbackId.isNull() && (len = ba.size()) >
    {
        char *buf = new char [len];
        memcpy(buf, ba.data(), len);
        m_data.speexdec.put(buf+4, len-4); //encodedBufWithTimeStamp
        delete [] buf;
        buf = 0;
    }
}//recvPlaybackDataIn()

void AudioEngine::setSelfLoop(bool flag)
{
    m_isSelfLoop = flag;
    if (m_isSelfLoop)
    {
        m_recorderId = “recorder”;
        m_playbackId = “playback”;
    }
}

Continue.

speex header file:

#ifndef _SAN_SPEEX_H_
#define _SAN_SPEEX_H_
//copy from speex_jitter_buffer.h(.c)
#include <speex/speex_jitter.h>
#include <speex/speex.h>
#include <speex/speex.h>
#include <speex/speex_jitter.h>
#include <speex/speex_preprocess.h>
#include <speex/speex_echo.h>
#ifdef __cplusplus
extern “C” {
#endif

/** @defgroup SpeexJitter SpeexJitter: Adaptive jitter buffer specifically for Speex
 *  This is the jitter buffer that reorders UDP/RTP packets and adjusts the buffer size
 * to maintain good quality and low latency. This is a simplified version that works only
 * with Speex, but is much easier to use.
 *  @{
*/

/** Speex jitter-buffer state. Never use it directly! */
typedef struct SpeexJitter {
   SpeexBits current_packet;         /**< Current Speex packet */
   int valid_bits;                   /**< True if Speex bits are valid */
   JitterBuffer *packets;            /**< Generic jitter buffer state */
   void *dec;                        /**< Pointer to Speex decoder */
   spx_int32_t frame_size;           /**< Frame size of Speex decoder */
} SpeexJitter;

/** Initialise jitter buffer
 *
 * @param jitter State of the Speex jitter buffer
 * @param decoder Speex decoder to call
 * @param sampling_rate Sampling rate used by the decoder
*/
void speex_jitter_init(SpeexJitter *jitter, void *decoder, int sampling_rate);

/** Destroy jitter buffer */
void speex_jitter_destroy(SpeexJitter *jitter);

/** Put one packet into the jitter buffer */
void speex_jitter_put(SpeexJitter *jitter, char *packet, int len, int timestamp);

/** Get one packet from the jitter buffer */
void speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *start_offset);

/** Get pointer timestamp of jitter buffer */
int speex_jitter_get_pointer_timestamp(SpeexJitter *jitter);

#ifdef __cplusplus
}
#endif
#define SAMPLING_RATE 16000
#define FRAME_SIZE 320
////////////////////////////////////////////////////////////////////

class SanSpeexEnc
{
public:
    SanSpeexEnc();
    ~SanSpeexEnc();

    /**
     * @return 4 + 4 + encodedLen
     * @rawin  must be 320 length
     *  4+encodedLen |   timestamp  | encodedBuf
     * ————–+————–+————–
     *  4            |   4          | encodedLen
     */
    int encode(const short *rawin, char *encodedBufOutWithTimestampAndLen);

    int playbackEcho(const short *rawin, bool ok); //TODO: remember to sync

    void captureEcho(short *rawin);
    void captureEcho(short *rawin, short *playback);

private:
    SpeexPreprocessState *preprocess;
    void                 *enc_state;
    SpeexBits             enc_bits;
    int                   send_timestamp;
    short                 pcm[FRAME_SIZE], pcm2[FRAME_SIZE];
    SpeexEchoState       *echo_state;
    char                  encodedBuf[FRAME_SIZE*2];

};
class SanSpeexDec
{
public:
    SanSpeexDec();
    ~SanSpeexDec();

    void setSanSpeexEnc(SanSpeexEnc *ptr);
    int put(const char *encodedBufWithTimestamp, int encodedLenWithTimestamp);
    int get(short *rawout);
    int afterPlayback(short *rawin, bool ok);

private:
   void               *dec_state;
   SpeexBits           dec_bits;
   short               pcm[FRAME_SIZE];
   SanSpeexEnc        *speexenc;
   SpeexJitter         jitter;
   int                 mostUpdatedTSatPut;
   bool                firsttimecalling_get;

};

/////////////////////////////////////////////////////////////////////

#endif // _SAN_SPEEX_H_

Speex source file:
#include <stdio.h>
#include <limits.h>
#include “san_speex.h”
#ifndef NULL
#define NULL 0
#endif
#define ENABLE_AEC
#ifdef ENABLE_AEC
 #define USE_AEC_CAPTURE          /* will print a lot of speex warning */
#endif

#include <qglobal.h>
//#define NEED_DUMP
#include <stdio.h>
FILE *file = 0;
char msg[128];
void debugPrint(const char *msg)
{
#ifdef NEED_DUMP
    if (file == 0)
        file = fopen(“dump.txt”, “a”);
    fprintf(file, msg);
#endif
}

void closeDebugPrint()
{
#ifdef NEED_DUMP
    if (file)
        fclose(file);
    file = 0;
#endif
}

#define ECHOTAILSIZE  25
short psSpeaker[320 * ECHOTAILSIZE * 10];
void speex_jitter_init(SpeexJitter *jitter, void *decoder, int sampling_rate)
{
   jitter->dec = decoder;
   speex_decoder_ctl(decoder, SPEEX_GET_FRAME_SIZE, &jitter->frame_size);

   jitter->packets = jitter_buffer_init(jitter->frame_size);

   speex_bits_init(&jitter->current_packet);
   jitter->valid_bits = 0;
}

void speex_jitter_destroy(SpeexJitter *jitter)
{
   jitter_buffer_destroy(jitter->packets);
   speex_bits_destroy(&jitter->current_packet);
}

void speex_jitter_put(SpeexJitter *jitter, char *packet, int len, int timestamp)
{
   JitterBufferPacket p;
   p.data = packet;
   p.len = len;
   p.timestamp = timestamp;
   p.span = jitter->frame_size;
   jitter_buffer_put(jitter->packets, &p);
   sprintf(msg, “put %d\n”, timestamp);
   debugPrint(msg);
}

void speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *current_timestamp)
{
   int i;
   int ret;
   spx_int32_t activity;
   int bufferCount = 0;
   JitterBufferPacket packet;
   //char data[40960];
   //packet.data = data;
   //packet.len = 40960;
   packet.data = reinterpret_cast<char *>(psSpeaker);
   packet.len = 320 * ECHOTAILSIZE * 10;
  
   if (jitter->valid_bits)
   {
      /* Try decoding last received packet */
      ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
      if (ret == 0)
      {
         jitter_buffer_tick(jitter->packets);
         return;
      } else {
         jitter->valid_bits = 0;
      }
   }

   if (current_timestamp)
    ret = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, current_timestamp);
   else
    ret = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, NULL);
  
   if (ret != JITTER_BUFFER_OK)
   {
      /* No packet found */
      speex_decode_int(jitter->dec, NULL, out);
   } else {
      speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
      /* Decode packet */
      ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
      if (ret == 0)
      {
         jitter->valid_bits = 1;
      } else {
         /* Error while decoding */
         for (i=0;i<jitter->frame_size;i++)
            out[i]=0;
      }
   }
   speex_decoder_ctl(jitter->dec, SPEEX_GET_ACTIVITY, &activity);
   if (activity < 30)
   {
      jitter_buffer_update_delay(jitter->packets, &packet, NULL);
   }
   jitter_buffer_tick(jitter->packets);
   //ret = jitter_buffer_ctl(jitter->packets, JITTER_BUFFER_GET_AVALIABLE_COUNT, &bufferCount);
   //sprintf(msg, “   get %d bufferCount=%d\n”, speex_jitter_get_pointer_timestamp(jitter), bufferCount);
   //debugPrint(msg);
}

int speex_jitter_get_pointer_timestamp(SpeexJitter *jitter)
{
   return jitter_buffer_get_pointer_timestamp(jitter->packets);
}
//===========================================================
SanSpeexEnc::SanSpeexEnc()
            :preprocess(0),
             enc_state(0),
             enc_bits(),
             send_timestamp(0),
             echo_state(0)
{
    for (int i=0; i<FRAME_SIZE; i++)
        pcm[i] = 0;

    int tmp;
    float tmpf;

    enc_state = speex_encoder_init(&speex_wb_mode);
    tmp = 3; //3,4,7,8,9,10 are not working
    speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);
    tmp = 7;
    speex_encoder_ctl(enc_state, SPEEX_SET_COMPLEXITY, &tmp);
    speex_bits_init(&enc_bits);

    echo_state = speex_echo_state_init(FRAME_SIZE, ECHOTAILSIZE*FRAME_SIZE);
    tmp = SAMPLING_RATE;
    speex_echo_ctl(echo_state, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);

    preprocess = speex_preprocess_state_init(FRAME_SIZE, SAMPLING_RATE);
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_ECHO_STATE, echo_state);

    tmp = 1;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
    tmp = 0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC, &tmp);
    tmp = 1;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_VAD, &tmp);

    tmp = 0;
 speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB, &tmp);
    tmpf = 0.0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &tmpf);
    tmpf = 0.0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &tmpf);

    tmp = 8000;//30000;
    //speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_TARGET, &tmp);
    tmp = 8000;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_LEVEL, &tmp);
    tmp = 5;
    //speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_MAX_GAIN, &tmp);
    tmp = -30;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &tmp);
}

SanSpeexEnc::~SanSpeexEnc()
{
    speex_encoder_destroy(enc_state); //–Destroy the encoder state
    speex_echo_state_destroy(echo_state);
    speex_preprocess_state_destroy(preprocess);
    speex_bits_destroy(&enc_bits); //–Destroy the bit-packing struct
    closeDebugPrint();
}

/**
 * @return 4 + 4 + encodedLen
 * @rawin  must be 320 length
 *  4+encodedLen |   timestamp  | encodedBuf
 * ————–+————–+————–
 *  4            |   4          | encodedLen
 */
int SanSpeexEnc::encode(const short *rawin, char *encodedBufOutWithTimestampAndLen)
{
#ifdef ENABLE_AEC
    /* Perform echo cancellation */
   #ifdef USE_AEC_CAPTURE
    speex_echo_capture(echo_state, rawin, pcm2);
   #else
    speex_echo_cancellation(echo_state, rawin, psSpeaker, pcm2);
   #endif
    for (int i=0;i<FRAME_SIZE;i++)
        pcm[i] = pcm2[i];
#else
    for (int i=0;i<FRAME_SIZE;i++)
        pcm[i] = rawin[i];
#endif

    speex_bits_reset(&enc_bits);

    /* Apply noise/echo suppression */
    bool isSpeech = speex_preprocess_run(preprocess, pcm);
    /* Encode */
    int needTransmit = speex_encode_int(enc_state, pcm, &enc_bits);
    int packetSize = 0;
    if (isSpeech && needTransmit)
    {
        packetSize = speex_bits_write(&enc_bits, encodedBufOutWithTimestampAndLen+8, FRAME_SIZE*2);
        
        ((int*)encodedBufOutWithTimestampAndLen)[0] = packetSize+4;
        ((int*)encodedBufOutWithTimestampAndLen)[1] = send_timestamp;
        qDebug(“packetSize=%d, timestamp=%d”, packetSize, send_timestamp);
    }

    send_timestamp += FRAME_SIZE;

    if (send_timestamp >= INT_MAX)
        send_timestamp = 0;

    if (packetSize > 0)
        return packetSize+4+4;
    else
        return 0;
}

int SanSpeexEnc::playbackEcho(const short *rawin, bool ok)
{
#ifdef ENABLE_AEC
    //TODO : sync
    /* Put frame into playback buffer */
   #ifdef USE_AEC_CAPTURE
    if (!ok)
        speex_echo_state_reset(echo_state);
    speex_echo_playback(echo_state, rawin);
   #endif
#endif
    return 1;
}

void SanSpeexEnc::captureEcho(short *rawin)
{
#ifdef ENABLE_AEC
   #ifdef USE_AEC_CAPTURE
    speex_echo_capture(echo_state, rawin, pcm2);
    for (int i=0; i<FRAME_SIZE; i++)
        rawin[i] = pcm2[i];

    speex_bits_reset(&enc_bits);
    speex_preprocess_run(preprocess, rawin);
   #endif
#endif
}

void SanSpeexEnc::captureEcho(short *rawin, short *playback)
{
#ifdef ENABLE_AEC
    speex_echo_cancellation(echo_state, rawin, playback, pcm2);
    speex_preprocess_run(preprocess, pcm2);
    for (int i=0; i<FRAME_SIZE; i++)
        rawin[i] = pcm2[i];
#endif
}

//==================================================
SanSpeexDec::SanSpeexDec()
            :dec_state(0),
             dec_bits(),
             speexenc(0),
             jitter(),
             mostUpdatedTSatPut(0),
             firsttimecalling_get(true)
{
    for (int i=0; i<FRAME_SIZE; i++)
        pcm[i] = 0;
    int tmp;

    dec_state = speex_decoder_init(&speex_wb_mode);
    tmp = 1;
    speex_decoder_ctl(dec_state, SPEEX_SET_ENH, &tmp);
    speex_bits_init(&dec_bits);
    speex_jitter_init(&jitter, dec_state, SAMPLING_RATE);
}

SanSpeexDec::~SanSpeexDec()
{
    speex_jitter_destroy(&jitter);

    //–Destroy the decoder state
    speex_decoder_destroy(dec_state);

    //–Destroy the bit-stream truct
    speex_bits_destroy(&dec_bits);
}

void SanSpeexDec::setSanSpeexEnc(SanSpeexEnc *ptr)
{
    speexenc = ptr;
}

int SanSpeexDec::put(const char *encodedBufWithTimestamp, int encodedLenWithTimestamp)
{
    //buffer:
    //  timestamp | encodedBuf
    // ———–+——————————
    //   4        | encodedLenWithTimestamp – 4
    int success = 0;
    int recv_timestamp = ((int*)encodedBufWithTimestamp)[0];
    mostUpdatedTSatPut = recv_timestamp;
    if (firsttimecalling_get)
        return 1;
    speex_jitter_put(&jitter, (char *)encodedBufWithTimestamp+4, encodedLenWithTimestamp-4, recv_timestamp);
    return 1;
}

int SanSpeexDec::get(short *rawout)
{
    if (firsttimecalling_get)
    {
        int ts = mostUpdatedTSatPut;
        sprintf(msg, “MostUpdatedTSatPut = %d\n”, ts);
        debugPrint(msg);
        firsttimecalling_get = false;
        speex_jitter_get(&jitter, rawout, &ts);
    }
    else
        speex_jitter_get(&jitter, rawout, 0);
    return 1;
}

int SanSpeexDec::afterPlayback(short *rawin, bool ok)
{
    if (speexenc)
        return speexenc->playbackEcho(rawin, ok);
    return 0;
}

Continue.

AudioClient header file:
#include “mysocket.h”

//==============================================================
MySocket::MySocket(const QString& myId)
         :m_socketdevice(0),
          m_running(false),
          m_amIClient(true),
          m_buf(0),
          m_bufLen(1024),
          m_myId(myId)
{
    m_socketdevice = new QSocketDevice();
    m_socketdevice->setAddressReusable(true);
    m_socketdevice->setBlocking(true);

    m_buf = new char[m_bufLen];
}

MySocket::~MySocket()
{
    stop();

    delete m_socketdevice;
    m_socketdevice = 0;

    delete [] m_buf;
    m_buf = 0;
}

void MySocket::setId(const QString& id)
{
    m_myId = id;
}

void MySocket::stop()
{
    if (m_running)
    {
        m_running = false;
    }
    if (m_socketdevice)
        m_socketdevice->close();
    //wait(500);
    qDebug(“MySocket::stop”);
}

bool MySocket::connectTo(const QString& serverAddr, int port)
{
    m_amIClient = true;
    if (!m_socketdevice)
        return false;

    bool ok = m_socketdevice->connect(serverAddr, port);
    wait(1000);
    if (ok)
    {
        QString handshake = “myid=” + m_myId;
        send(handshake);
    }
    return ok;
}

void MySocket::setSocket(int socket)
{
    m_amIClient = false;
    m_socketdevice->setSocket(socket, QSocketDevice::Stream);
}

bool MySocket::hasError()
{
    if (!m_socketdevice)
        return true;
    return (m_socketdevice->error() != QSocketDevice::NoError);
}

void MySocket::run()
{
    m_running = true;

    if (m_socketdevice)
    {
        qDebug(“port/peerPort = %d,%d”, m_socketdevice->port(), m_socketdevice->peerPort());
    }

    int len = 0;
    int readLen = 0;
    while (m_running && m_socketdevice && !hasError())
    {
        len = m_socketdevice->bytesAvailable();
        if (len > 0)
        {
            if (len > m_bufLen)
            {
                m_bufLen = len;
                delete [] m_buf;
                m_buf = new char[m_bufLen];
            }

            readLen = m_socketdevice->readBlock(m_buf, len);
            if (readLen <= 0) //error
            {
                qDebug(“—– read error — 1″);
                m_running = false;
                break;
            }
            while (readLen < len && !hasError())
            {
                int curLen = m_socketdevice->readBlock(m_buf + readLen, len – readLen);
                if (curLen <= 0) //error
                {
                    qDebug(“—– read error — 3″);
                    m_running = false;
                    break;
                }
                readLen += curLen;
            }
            if (!m_running)
                break;

            QByteArray ba(len);
            const char *data = ba.data();
            memcpy(ba.data(), m_buf, len);
            if (len > 5 && data[0] == ‘m’ && data[1] == ‘y’ && data[2] == ‘i’ && data[3] == ‘d’ && data[4] == ‘=’)
            {
                QString handshake(ba);
                QString hisId = handshake.mid(5);
                emit fireReceivedHandshake(m_socketdevice->socket(), hisId);
            }
            else if (len > 3 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’ && data[3] == ‘Q’)
            {
                m_running = false;
                qDebug(“MySocket::run() got cmdQ”);
                emit fireReceivedData(ba);
            }
            else
                emit fireReceivedData(ba);
        }
        else
        {
            len = m_socketdevice->waitForMore(100);
            if (len == -1 || hasError()) //error
            {
                qDebug(“—– read error — 2″);
                m_running = false;
                break;
            }
        }
    }//while()
    qDebug(“—– done MySocket::run() —-”);
}//run()

bool MySocket::send(const QByteArray& ba)
{
    bool success = false;
    if (!m_socketdevice)
        return success;

    const char *data = ba.data();
    int len = ba.size();
    int writtenLen = 0;

   
    writtenLen = m_socketdevice->writeBlock(data, len);
    while (writtenLen < len)
    {
        writtenLen += m_socketdevice->writeBlock(data + writtenLen, len – writtenLen);
    }

    return (writtenLen == len);
}

bool MySocket::send(const QString& str)
{
    QCString cstr = str.utf8();
    const char *data = (const char *)(cstr);
    QByteArray ba(cstr.length());
    memcpy(ba.data(), data, cstr.length());

    return send(ba);
}
//=====================================================
MyServerSocket::MyServerSocket(Q_UINT16 port)
               :QServerSocket(port),
                m_mysocketDict(), //key=socket(int)
                m_map() //socket(int), id(Qstring)
{
    m_mysocketDict.setAutoDelete(true);
}

MyServerSocket::~MyServerSocket()
{
    m_mysocketDict.clear();
    m_map.clear();
}

void MyServerSocket::newConnection(int socket)
{
    MySocket *mysocket = new MySocket();
    connect(mysocket, SIGNAL(fireReceivedData(const QByteArray&)),
                      SIGNAL(fireReceivedData(const QByteArray&)));
    connect(mysocket, SIGNAL(fireReceivedHandshake(int, const QString&)),
                      SLOT(slotReceivedHandshake(int, const QString&)));
    m_map.insert(socket, QString(“”));
    m_mysocketDict.insert(QString::number(socket), mysocket);
    mysocket->setSocket(socket);
    mysocket->start();
}

bool MyServerSocket::send(const QByteArray& ba, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(ba);
            }
        }
    }
    return false;
}

bool MyServerSocket::send(const QString& str, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(str);
            }
        }
    }
    return false;
}

void MyServerSocket::stop()
{
    QDictIterator<MySocket> it(m_mysocketDict);
    MySocket *sock = 0;
    for ( ; (sock = it.current()); ++it)
    {
        sock->stop();
    }
}

void MyServerSocket::slotReceivedHandshake(int socket, const QString& hisId)
{
    qDebug(“—- receive handshake :” + QString::number(socket) + ” =” + hisId);
    m_map.insert(socket, hisId, true);
    MySocket *sock = m_mysocketDict.find(QString::number(socket));
    if (sock)
    {
        sock->setId(hisId);
        emit fireReceivedHandshake(hisId);
    }
}

 AudioClient source file:

#include “audioclient.h”
#include <qpushbutton.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qapplication.h>

//===================================
AudioClient::AudioClient(int serverPort, bool isRecorder)
            :QWidget(),
             m_socket(0),
             m_setBtn(0),
             m_startBtn(0),
             m_stopBtn(0),
             m_edit(0),
             m_isRecorder(isRecorder)
{
    m_socket = new MySocket(isRecorder ? “recorder” : “playback”);
    connect(m_socket, SIGNAL(fireReceivedData(const QByteArray&)),
                      SLOT(slotReceivedData(const QByteArray&)));

    QVBoxLayout *vlayout = new QVBoxLayout(this);

    QHBoxLayout *h1 = new QHBoxLayout(0);
    QLabel *label1 = new QLabel(“Set Device Index:”, this);
    m_edit = new QLineEdit(this);
    m_edit->setText(isRecorder ? “1″ : “7″);
    m_setBtn = new QPushButton(isRecorder ? “Set Capture Dev” : “Set Playback Dev”, this);
    h1->addWidget(label1);
    h1->addWidget(m_edit);
    h1->addWidget(m_setBtn);
    vlayout->addItem(h1);

    QHBoxLayout *h2 = new QHBoxLayout(0);
    QLabel *label2 = new QLabel(isRecorder ? “Start Capture” : “Start Playback”, this);
    m_startBtn = new QPushButton(“Start”, this);
    h2->addWidget(label2);
    h2->addWidget(m_startBtn);
    vlayout->addItem(h2);

    QHBoxLayout *h3 = new QHBoxLayout(0);
    QLabel *label3 = new QLabel(isRecorder ? “Stop Capture” : “Stop Playback”, this);
    m_stopBtn = new QPushButton(“Stop”, this);
    h3->addWidget(label3);
    h3->addWidget(m_stopBtn);
    vlayout->addItem(h3);

    QPushButton *exitBtn = new QPushButton(“Exit”, this);
    vlayout->addWidget(exitBtn);

    connect(m_setBtn,   SIGNAL(clicked()), SLOT(slotSetClicked()));
    connect(m_startBtn, SIGNAL(clicked()), SLOT(slotStartClicked()));
    connect(m_stopBtn,  SIGNAL(clicked()), SLOT(slotStopClicked()));
    connect(exitBtn,    SIGNAL(clicked()), SLOT(slotExitClicked()));

    move(isRecorder ? 30 : 130, isRecorder ? 30 : 130);
    setCaption(isRecorder ? “RecorderClient” : “PlaybackClient”);

    bool ok = m_socket->connectTo(“127.0.0.1″, serverPort);
    qDebug(“connect to = %d”, ok);
    if (ok)
        m_socket->start();
}

AudioClient::~AudioClient()
{
    delete m_socket;
    m_socket = 0;
}

void AudioClient::slotSetClicked()
{
    QString str = m_isRecorder ? “cmd2″ : “cmd3″;
    str += m_edit->text().stripWhiteSpace();
    m_socket->send(str);
    m_setBtn->setEnabled(false);
}

void AudioClient::slotStartClicked()
{
    m_socket->send(m_isRecorder ? “cmd4″ : “cmd5″);
    m_startBtn->setEnabled(false);
}

void AudioClient::slotStopClicked()
{
    m_socket->send(m_isRecorder ? “cmd6″ : “cmd7″);
    m_stopBtn->setEnabled(false);
}

void AudioClient::slotExitClicked()
{
    if (m_socket && m_socket->isValid())
    {
        m_socket->send(“cmdQ”);
        m_socket->stop();
    }
    close();
    qApp->quit();
}

void AudioClient::closeEvent(QCloseEvent *)
{
    if (m_socket && m_socket->isValid())
    {
        m_socket->send(“cmdQ”);
        m_socket->stop();
    }
    qApp->quit();
}

void AudioClient::slotReceivedData(const QByteArray& ba)
{
    const char *data = ba.data();
    if (ba.size() >= 4 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’)
    {
        char cmd = data[3];
        switch (cmd)
        {
        case ‘1′: //return device list;   dev1\ndev2\n…
            {
                QString devList(ba);
                devList = devList.mid(4);
                qDebug(“1. DevList = ” + devList);
            }
            break;
        case ‘2′: //set recorder device;  devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“2. RecorderDevice = ” + devName);
            }
            break;
        case ‘3′: //set playback device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“3. PlaybackDevice = ” + devName);
            }
            break;
        case ‘4′: //start recorder
            qDebug(“4. Start Recording”);
            break;
        case ‘5′: //start playback
            qDebug(“5. Start Playback”);
            break;
        case ‘6′: //stop recorder
            qDebug(“6. Stop Recording”);
            break;
        case ‘7′: //stop playback
            qDebug(“7. Stop Playback”);
            break;
        case ‘Q’:
            qDebug(“Q. Quit”);
            slotExitClicked();
            break;
        default:
            break;
        }
    }//cmd
    else
    {
        if (ba.size() >
        {
            const char *data = ba.data();
            int packetSize = ((int*)data)[0];
            int timestamp = ((int*)data)[1];
            qDebug(“got packetSize=%d, timestamp=%d”, packetSize, timestamp);
        }
    }
}//slotReceivedData()

This is a testing program I wrote in QT3 to test audio capture/playback loop in a local machine. Using 2 testing clients to communicate with AudioEngine which handling audio capturing/playing. Of course, need a lot of improvement on audio quality and AGC, AEC… ,etc.

socket header file:
#ifndef _MYSOCKET_H_
#define _MYSOCKET_H_

#include <qsocketdevice.h>
#include <qthread.h>
#include <qobject.h>
#include <qserversocket.h>
#include <qdict.h>
#include <qmap.h>

//==============================================
class MySocket : public QObject, public QThread
{
    Q_OBJECT
public:
    MySocket(const QString& myId = QString::null);
    ~MySocket();

    //I am client
    bool connectTo(const QString& serverAddr, int port);

    //I am server
    void setSocket(int socket);
    void setId(const QString& id);

    bool send(const QByteArray&);
    bool send(const QString& str);
    void stop();

    bool isValid() { return (m_socketdevice && m_socketdevice->isValid()); }

signals:
    void fireReceivedData(const QByteArray&);
    void fireReceivedHandshake(int socket, const QString&);

protected:
    virtual void run();

private:
    bool             hasError();

    QSocketDevice   *m_socketdevice;
    bool             m_running;
    bool             m_amIClient;
    char            *m_buf;
    int              m_bufLen;
    QString          m_myId;
};
//=====================================================
class MyServerSocket : public QServerSocket
{
    Q_OBJECT
public:
    MyServerSocket(Q_UINT16 port = 4242);
    ~MyServerSocket();

    bool send(const QByteArray&, const QString& id);
    bool send(const QString&, const QString& id);
    void stop();

signals:
    void fireReceivedData(const QByteArray&);
    void fireReceivedHandshake(const QString& hisId);

private slots:
    void slotReceivedHandshake(int socket, const QString& hisId);

protected:
    virtual void newConnection(int socket);

private:
    QDict<MySocket>      m_mysocketDict; //key=socket(int)
    QMap<int, QString>   m_map;
};
#endif // _MYSOCKET_H_

socket source file:
#include “mysocket.h”

//==============================================================
MySocket::MySocket(const QString& myId)
         :m_socketdevice(0),
          m_running(false),
          m_amIClient(true),
          m_buf(0),
          m_bufLen(1024),
          m_myId(myId)
{
    m_socketdevice = new QSocketDevice();
    m_socketdevice->setAddressReusable(true);
    m_socketdevice->setBlocking(true);

    m_buf = new char[m_bufLen];
}

MySocket::~MySocket()
{
    stop();

    delete m_socketdevice;
    m_socketdevice = 0;

    delete [] m_buf;
    m_buf = 0;
}

void MySocket::setId(const QString& id)
{
    m_myId = id;
}

void MySocket::stop()
{
    if (m_running)
    {
        m_running = false;
    }
    if (m_socketdevice)
        m_socketdevice->close();
    //wait(500);
    qDebug(“MySocket::stop”);
}

bool MySocket::connectTo(const QString& serverAddr, int port)
{
    m_amIClient = true;
    if (!m_socketdevice)
        return false;

    bool ok = m_socketdevice->connect(serverAddr, port);
    wait(1000);
    if (ok)
    {
        QString handshake = “myid=” + m_myId;
        send(handshake);
    }
    return ok;
}

void MySocket::setSocket(int socket)
{
    m_amIClient = false;
    m_socketdevice->setSocket(socket, QSocketDevice::Stream);
}

bool MySocket::hasError()
{
    if (!m_socketdevice)
        return true;
    return (m_socketdevice->error() != QSocketDevice::NoError);
}

void MySocket::run()
{
    m_running = true;

    if (m_socketdevice)
    {
        qDebug(“port/peerPort = %d,%d”, m_socketdevice->port(), m_socketdevice->peerPort());
    }

    int len = 0;
    int readLen = 0;
    while (m_running && m_socketdevice && !hasError())
    {
        len = m_socketdevice->bytesAvailable();
        if (len > 0)
        {
            if (len > m_bufLen)
            {
                m_bufLen = len;
                delete [] m_buf;
                m_buf = new char[m_bufLen];
            }

            readLen = m_socketdevice->readBlock(m_buf, len);
            if (readLen <= 0) //error
            {
                qDebug(“—– read error — 1″);
                m_running = false;
                break;
            }
            while (readLen < len && !hasError())
            {
                int curLen = m_socketdevice->readBlock(m_buf + readLen, len – readLen);
                if (curLen <= 0) //error
                {
                    qDebug(“—– read error — 3″);
                    m_running = false;
                    break;
                }
                readLen += curLen;
            }
            if (!m_running)
                break;

            QByteArray ba(len);
            const char *data = ba.data();
            memcpy(ba.data(), m_buf, len);
            if (len > 5 && data[0] == ‘m’ && data[1] == ‘y’ && data[2] == ‘i’ && data[3] == ‘d’ && data[4] == ‘=’)
            {
                QString handshake(ba);
                QString hisId = handshake.mid(5);
                emit fireReceivedHandshake(m_socketdevice->socket(), hisId);
            }
            else if (len > 3 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’ && data[3] == ‘Q’)
            {
                m_running = false;
                qDebug(“MySocket::run() got cmdQ”);
                emit fireReceivedData(ba);
            }
            else
                emit fireReceivedData(ba);
        }
        else
        {
            len = m_socketdevice->waitForMore(100);
            if (len == -1 || hasError()) //error
            {
                qDebug(“—– read error — 2″);
                m_running = false;
                break;
            }
        }
    }//while()
    qDebug(“—– done MySocket::run() —-”);
}//run()

bool MySocket::send(const QByteArray& ba)
{
    bool success = false;
    if (!m_socketdevice)
        return success;

    const char *data = ba.data();
    int len = ba.size();
    int writtenLen = 0;

   
    writtenLen = m_socketdevice->writeBlock(data, len);
    while (writtenLen < len)
    {
        writtenLen += m_socketdevice->writeBlock(data + writtenLen, len – writtenLen);
    }

    return (writtenLen == len);
}

bool MySocket::send(const QString& str)
{
    QCString cstr = str.utf8();
    const char *data = (const char *)(cstr);
    QByteArray ba(cstr.length());
    memcpy(ba.data(), data, cstr.length());

    return send(ba);
}
//=====================================================
MyServerSocket::MyServerSocket(Q_UINT16 port)
               :QServerSocket(port),
                m_mysocketDict(), //key=socket(int)
                m_map() //socket(int), id(Qstring)
{
    m_mysocketDict.setAutoDelete(true);
}

MyServerSocket::~MyServerSocket()
{
    m_mysocketDict.clear();
    m_map.clear();
}

void MyServerSocket::newConnection(int socket)
{
    MySocket *mysocket = new MySocket();
    connect(mysocket, SIGNAL(fireReceivedData(const QByteArray&)),
                      SIGNAL(fireReceivedData(const QByteArray&)));
    connect(mysocket, SIGNAL(fireReceivedHandshake(int, const QString&)),
                      SLOT(slotReceivedHandshake(int, const QString&)));
    m_map.insert(socket, QString(“”));
    m_mysocketDict.insert(QString::number(socket), mysocket);
    mysocket->setSocket(socket);
    mysocket->start();
}

bool MyServerSocket::send(const QByteArray& ba, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(ba);
            }
        }
    }
    return false;
}

bool MyServerSocket::send(const QString& str, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(str);
            }
        }
    }
    return false;
}

void MyServerSocket::stop()
{
    QDictIterator<MySocket> it(m_mysocketDict);
    MySocket *sock = 0;
    for ( ; (sock = it.current()); ++it)
    {
        sock->stop();
    }
}

void MyServerSocket::slotReceivedHandshake(int socket, const QString& hisId)
{
    qDebug(“—- receive handshake :” + QString::number(socket) + ” =” + hisId);
    m_map.insert(socket, hisId, true);
    MySocket *sock = m_mysocketDict.find(QString::number(socket));
    if (sock)
    {
        sock->setId(hisId);
        emit fireReceivedHandshake(hisId);
    }
}

CorePlayer is designed to be a next-generation multimedia platform that will extend upon what you thought were limits in playing back fluid multiemdia , with its simple yet extremely powerful interfaceand features that is designed to empower the CoreCodec Community.

See why companies like Joost, SanDisk, DivX, Elgato and more are using CoreCodec technology and why the Chicago Suntimes times says that CorePlayer, “actually has a user interface designed with bipeds in mind.”

Technology Overview:
* H.264 Ready with CoreAVC
* Built-In YouTube Support
* Flash/FLV Container Support
* Bluetooth ready!* (A2DP and AVRCP)
* Supports over 22 Languages (20+ more coming soon!)
* Podcast, Enhanced Podcast, CoreCaster Ready
* CoreUI ‘Universal skins’ Widget. Allows you to create a unique custom user interface exactly how you want it!
* Best in Class audio and video codecs like CoreAVC our High Definition H.264 video decoder
* CoreTheque media library allows for easy management of your playlists and bookmarks

Download Link : Core Player

CorePlayer is designed to be a next-generation multimedia platform that will extend upon what you thought were limits in playing back fluid multiemdia , with its simple yet extremely powerful interfaceand features that is designed to empower the CoreCodec Community.

See why companies like Joost, SanDisk, DivX, Elgato and more are using CoreCodec technology and why the Chicago Suntimes times says that CorePlayer, “actually has a user interface designed with bipeds in mind.”

Technology Overview:
* H.264 Ready with CoreAVC
* Built-In YouTube Support
* Flash/FLV Container Support
* Bluetooth ready!* (A2DP and AVRCP)
* Supports over 22 Languages (20+ more coming soon!)
* Podcast, Enhanced Podcast, CoreCaster Ready
* CoreUI ‘Universal skins’ Widget. Allows you to create a unique custom user interface exactly how you want it!
* Best in Class audio and video codecs like CoreAVC our High Definition H.264 video decoder
* CoreTheque media library allows for easy management of your playlists and bookmarks

Download Link : Core Player

CorePlayer is designed to be a next-generation multimedia platform that will extend upon what you thought were limits in playing back fluid multimedia, with its simple yet extremely powerful interface and features that is designed to empower the CoreCodec Community.

See why companies like Joost, SanDisk, DivX, Elgato and more are using CoreCodec technology and why the Chicago Suntimes times says that CorePlayer, “actually has a user interface designed with bipeds in mind.”

Technology Overview:
* H.264 Ready with CoreAVC
* Built-In YouTube Support
* Flash/FLV Container Support
* Bluetooth ready!* (A2DP and AVRCP)
* Supports over 22 Languages (20+ more coming soon!)
* Podcast, Enhanced Podcast, CoreCaster Ready
* CoreUI ‘Universal skins’ Widget. Allows you to create a unique custom user interface exactly how you want it!
* Best in Class audio and video codecs like CoreAVC our High Definition H.264 video decoder
* CoreTheque media library allows for easy management of your playlists and bookmarks

Audio Formats:
MP3, MP2, AAC, MKA, WMA, Midi*, WAV, OGG, Speex, WAVPACK, TTA, FLAC, MPC, AMR, ADPCM, ALaw, MuLaw, G.729, GSM

Video Formats:
H.264 (AVC), AVCHD, MKV, MPEG-1, MPEG-4 part 2 (ASP), DivX, XviD, WMV*, Theora*, Dirac*, MJPEG, MSVIDEO1

Image Formats:
JPEG (420, 422, 440, EXIF Headers)*, BMP, GIF, PNG, TIFF, MJPEG

Container Formats:
Flash/FLV, Matroska, ASF, ASX, AVI, PS, M2TS, TS, 3GPP, MOV,MPEG-4, OGM, NSV

Streaming Formats:
HTTP, UDP, UDP Multicast, UDP Unicast, RDP, RTP. RTSP, RTCP(keep alive), ASX, ASF, Multicast, HTTP Tunneling

Additional Features:
Google Data, Benchmarking, Integrated Pocket IE/IE Support, SMB Browsing

Compatibility:
For Symbian 9.1/9.2/9.3 (S60v3) mobiles like N73, N76, N81, N81 8GB, N82, N95, N95 8GB, etc.

Download: 2MB

Foobar2000 is an advanced freeware audio player for the Windows platform. Some of the basic features include full unicode support, ReplayGain support and native support for several popular audio formats. The foobar2000 player supports the following audio formats: MP3, MP4, AAC, CD Audio, WMA, Vorbis, FLAC, WavPack, WAV, AIFF, Musepack, Speex, AU, SND and even more with the help of additional components. One of the biggest advantages of the player is the open component architecture allowing third-party developers to extend functionality of the player. With foobar2000 you also get support for gapless playback, easily customizable user interface layout, advanced tagging capabilities, support for ripping Audio CDs as well as transcoding all supported audio formats using the Converter component and even more…

- Download Foobar2000 9.6.8 Music Player
- Download Foobar2000 9.6.8 Music Player (mirror 1)
- Download Foobar2000 9.6.8 Music Player (mirror 2)
- Download Foobar2000 9.6.8 Music Player (mirror 3)

foobar2000 is an advanced freeware audio player for the Windows platform. Some of the basic features include full unicode support, ReplayGain support and native support for several popular audio formats. The foobar2000 player supports the following audio formats: MP3, MP4, AAC, CD Audio, WMA, Vorbis, FLAC, WavPack, WAV, AIFF, Musepack, Speex, AU, SND and even more with the help of additional components. One of the biggest advantages of the player is the open component architecture allowing third-party developers to extend functionality of the player. With foobaer2000 you also get support for gapless playback, easily customizable user interface layout, advanced tagging capabilities, support for ripping Audio CDs as well as transcoding all supported audio formats using the Converter component and even more…

- Download Foobar2000 9.6.5 Music Player

Je me suis trouvé souvent dans le situation de vouloir écouter des fichiers audio sur un appareil qui ne connaissait pas le format utilisé (le plus souvent Ogg ou Speex). Tous les appareils lisent le MP3 en revanche. J’ai donc voulu trouver un utilitaire pour faire la conversion.

Pour convertir des fichiers ogg en mp3, tout est expliqué ici. Pour les speex (extension .spx), le principe est le même, mais en utilisant la commande speexdec au lieu de oggdec afin de convertir le fichier en wav (la syntaxe est un tout petit peu différente).

Note : Je suis sous Linux, mais on doit pouvoir faire fonctionner ce script sous Windows avec Cygwin.

(13:06:37) » Join: Ownijs (~no@87.110.144.163)
(13:06:39) Ownijs: URLAS KROPLI, MAUKAS BLEE!!!! nosprāgstiet kukainji tizlie!!!!
(13:06:40) » Part: Ownijs (~no@87.110.144.163)

The inclusion of p2p in the Flash 10 beta threatens to bring down everyone from YouTube to Skype. Using P2P, Flash sites will be able to serve higher quality video than YouTube at a fraction of the cost. Meanwhile, the combination of the Speex audio codec and the Real Time Media Flow Protocol (RTMFP) will enable sites to seamlessly integrate VoIP without requiring a Skype install. The impact of this change is hard to fathom. We’re talking about a fundamental shift in what is possible on the Internet, with Flash demolishing almost all barriers to integrating P2P on any site.

Hank Williams and Om Malik have discussed the potential for Flash 10 to be used for P2P CDNs, and they’re largely right on. The biggest problem I see with P2P CDNs is oddly latency, however. While P2P theoretically enables you to choose copies of content closer to you on the network, you still have to negotiate with a server somewhere to establish the connection (for traversing NATs), nullifying the P2P advantage unless you’re talking about really big files. As Hank identifies, the sites serving large files are the CDN’s best customers, so we are talking about a significant chunk of the CDN business up for grabs. That said, CDNs could easily start running Flash Media Servers themselves with integrated RTMFP. They’ve already addressed the server locality problem, and taking advantage of Flash deployments would simply be an optimization. Whether the CDNs will realize this shift has taken place before it’s too late is another question.

To me, the really vulnerable players are the video sites themselves and anyone in the client-side VoIP space. Writing a VoIP app is now equivalent to writing your own Flash video player. All the hard stuff is already done. Same with serving videos. You no longer have to worry about setting up an infinitely scalable server cluster — you just offload everything to Flash. No more heavy lifting and no more huge bandwidth bills. In the BitTorrent case, it’s mostly a matter of usability. As with Skype, you no longer need a separate install. Depending on what’s built in to the Flash Media Server, you also no longer need to worry about complicated changes on the server side, and downloads will happen right in the browser.

The stunning engineering behind all of this should be adequately noted. The Real Time Media Flow Protocol (RTMFP) underlies all of these changes. On closer inspection, RTMFP appears to be the latest iteration of Matthew Kaufman and Michael Thornburgh’s Secure Media Flow Protocol (SMP) from Adobe’s 2006 acquisition of Amicima. Adobe appears to have acquired Amicima specifically to integrate SMP into Flash, now in the improved form of RTMFP. This is a very fast media transfer protocol built on UDP with IPSec-like security and congestion control built in. The strength of the protocol was clear to me when Matthew first posted his “preannouncement” on the p2p hackers list. Very shrewd move on Adobe’s part.

Are there any downsides? Well, RTMFP, is for now a closed if breathtakingly cool protocol, and it’s tied to Flash Media Server. That means Adobe holds all the cards, and this isn’t quite the open media platform to end all platforms. If they open up the protocol and open source implementations start emerging, however, the game’s over.

Not that I have much sympathy, but this will also shift a huge amount of traffic to ISPs, as ISPs effectively take the place of CDNs without getting paid for it. While Flash could implement the emerging P4P standards to limit the bleeding at the ISPs and to further improve performance, this will otherwise eventually result in higher bandwidth bills for consumers over the long term. No matter — I’d rather have us all pay a little more in exchange for dramatically increasing the numbers of people who can set up high bandwidth sites on the Internet. The free speech implications are too good to pass up.

Just to clear up some earlier confusion, Flash Beta 10 is not based on SIP or P2P-SIP in any way. Adobe’s SIP work has so far only seen the light of day in Adobe Pacifica, but not in the Flash Player.