linaudiodevice.cxx

SIP（Session Initiation Protocol）是由IETF定义

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact [e-mail].
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */

#include "global.h"

#include "Rtp.hxx"
#include "codec/g711.h"
#include "VCondition.h"
#include "LinAudioDevice.hxx"
#include "MediaController.hxx"
#include "CodecG711U.hxx"

using namespace Vocal;
using namespace Vocal::UA;

#define RESID_RTP_RATE 160      // 320 byte packet size

LinAudioDevice::LinAudioDevice( const char* deviceName)
    : MediaDevice(SOUNDCARD, AUDIO), 
      mySoundCard(deviceName)
{
    // open audio hardware device
    if( mySoundCard.open() == -1 )
    {
        cpLog( LOG_ERR, "Failed to open %s", deviceName );
        exit( -1 );
    }

    cpLog(LOG_DEBUG, "Opened audio device");
    myAudioThread->run();
    myCodec = new CodecG711U();
    audioActive = false;

} // end LinAudioDevice::LinAudioDevice()



//***************************************************************************
// LinAudioDevice::~LinAudioDevice
// description:  Destructor
//***************************************************************************

LinAudioDevice::~LinAudioDevice()
{
    mySoundCard.close();
} // end LinAudioDevice::~LinAudioDevice()


void
LinAudioDevice::processOutgoingAudio()
{
    if(!audioActive)
        return;
    int cc;
    cc = mySoundCard.read( dataBuffer, RESID_RTP_RATE );
    if ((cc > 0)) 
    {
        //Send raw packet to Controller
        cpLog(LOG_DEBUG_STACK, "LinAudioDevice::processOutgoingAudio");
        processRaw((char*)dataBuffer, cc, G711U);
    }
    else
    {
        cpLog(LOG_DEBUG, "failed to read data from sound card");
    }
}

void
LinAudioDevice::processAudio()
{
    myMutex.lock();
    if(!audioActive)
    {
        myMutex.unlock();
        vusleep(50000);
        return;
    }
    int myFD = mySoundCard.getFd();


    myMutex.unlock();
    fd_set netFD;
    FD_ZERO (&netFD);
    if(myFD >= 0)
    {
        FD_SET(myFD, &netFD);
    }

    int maxfd = myFD;

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

    struct timeval timeout;
    timeout.tv_sec = 1;
    timeout.tv_usec = 0;

    int selret = select(maxfd + 1, &netFD, 0, 0, &timeout);

    if(selret >= 0)
    {
        myMutex.lock();
        processOutgoingAudio();
        myMutex.unlock();
    }

    return;
}


int
LinAudioDevice::start()
{
    cerr << "%%% Starting audio" << endl;
    Lock lock(myMutex);
    if( audioActive )
    {
        return 1;
    }
    audioActive = true;

    MediaDevice::start();

    mySoundCard.reopen();

    return 0;
} // end LinAudioDevice::start()

int
LinAudioDevice::stop()
{
    Lock lock(myMutex);


    if( !audioActive )
    {
        return 1;
    }

    //Stop the base class
    MediaDevice::stop();

    cerr << "%%% Stopping audio" << endl;
    audioActive = false;
    mySoundCard.reopen();
    return 0;
} 

void 
LinAudioDevice::sinkData(char* data, int length, VCodecType type)
{
    Lock lock(myMutex);
    cpLog(LOG_DEBUG_STACK, "Sink Data: length %d", length);
    if(type == DTMF_TONE)
    {
        char digit;
        memcpy(&digit, data, 1);
        cpLog( LOG_DEBUG, "***  DTMF %c  ***", digit );
        return;
    }
    
    if(type != myCodec->getType())
    {
        //First convert the data from type to myType and then feed
        //it to the soundcard
        cpLog(LOG_ERR, "Need codec conversion!!!!");
        Sptr<CodecAdaptor> cAdp =
        MediaController::instance().getMediaCapability().getCodec(type);
        ///Convert from codec type to PCM
        int decLen = 1024;
        char decBuf[1024];
        cAdp->decode(data, length, decBuf, decLen);
        int encLen = 1024;
        char encBuf[1024];
        myCodec->encode(decBuf, decLen, encBuf, encLen);
        mySoundCard.write( (unsigned char*) encBuf, encLen);
    }
    else
    {
        mySoundCard.write( (unsigned char*) data, length);
    }
}

int
LinAudioDevice::suspend()
{
    Lock lock(myMutex);
    cerr << "%%% Suspending audio" << endl;
    audioActive = false;
    return(mySoundCard.close());
}

int
LinAudioDevice::resume()
{
    Lock lock(myMutex);
    cerr << "%%% Resuming audio" << endl;
    audioActive = true;
    return(mySoundCard.reopen());
}



/* Local Variables: */
/* c-file-style: "stroustrup" */
/* indent-tabs-mode: nil */
/* c-file-offsets: ((access-label . -) (inclass . ++)) */
/* c-basic-offset: 4 */
/* End: */