---

PlayOp.cpp

Go to the documentation of this file.

/*
 * PlayOp.cpp
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

#include <bogotel/portability.h>
#include <bogotel/PlayOp.h>
#include <bogotel/TermParms.h>

#include <sys/stat.h>
#include <sys/types.h>

#include <bogotel/BgtErrors.h>

namespace bogotel {

    const char *CPlayOp::s_szName      = "CPlayOp";

    CPlayOp::CPlayOp(CVoiceDev* pVD, const DX_IOTT* pIOTT, const DV_TPT* pTPT) throw (std::invalid_argument) :
    CIOOp(pVD),
    m_pIott(pIOTT),
    m_bWasWavPlayed(false),
    m_pTermParms(NULL)
    {
        char method[] = "CPlayOp::CPlayOp";
        if (pTPT != NULL) {
            try {
                m_pTermParms = new CTermParms(pVD, this, pTPT);
            } catch (std::invalid_argument& except) {
                log(3, "%s: new CTermParms threw exception", method, except.what());
                throw;
            }
        }
        processIottEntry();
    }

    CPlayOp::~CPlayOp()
    {
        delete m_pTermParms;
        CIOOp::~CIOOp();
    }

    void CPlayOp::start() 
    {
        if (m_pTermParms) {
            m_pTermParms->start();
        }
    }

    std::string CPlayOp::toString()
    {
        return CTimerTarget::toString() + " " + s_szName;
    }

    long CPlayOp::terminationEvent()
    {
        return TDX_PLAY;
    }

    // this is called when a wav has finished playing
    // and it means that it is time to play the next one
    void CPlayOp::_timerExpired(int timerType, int stateId)
    {
        char method[] = "CPlayOp::_timerExpired";
        switch (timerType) {
        case timerType::singleWav:
            processIottEntry();
            break;
        case CTermParms::timerType::MaxSil:
        case CTermParms::timerType::MaxTime:
        case CTermParms::timerType::IddTime:
            m_pTermParms->timerExpired(timerType, stateId);
            break;
        default:
            log(3, "%s: Invalid timerType", method, timerType);
            break;
        }
    }

    void CPlayOp::processIottEntry() throw (std::invalid_argument)
    {
        char method[] = "CPlayOp::processIottEntry";

        if (m_pIott == NULL) {
            // we've finished all entries -- send normal termination
            if (m_bWasWavPlayed)  {
                m_pVD->sendPlayFinishedMsg();
            }
            terminate(TM_NORMTERM);
            return;
        }

        std::string strFilename;
        long lDuration;

        // get filename from map
        MAP_INT2STR::iterator it;
        int hFile(m_pIott->io_fhandle);
        it = CVoiceDev::s_mapHandle2Filename.find(hFile);
        if (it == CVoiceDev::s_mapHandle2Filename.end()) {
            log(3, "%s: file handle not stored in map", method);
            throw std::invalid_argument(std::string(method) + ": file handle not stored in map");
        }
        strFilename = it->second;

        int rc;
        if ((rc = getWavDuration(hFile, &lDuration)) != resultSUCCESS) {
            log(3, "%s: getWavDuration() failed. filename is %s, rc is %d", 
                method, strFilename.c_str(), rc);
            throw std::invalid_argument(std::string(method) + ": getWavDuration() failed");
        }

        m_pVD->sendPlayMsg(strFilename);
        m_bWasWavPlayed = true;

        // schedule timer for end of "playback"
        setTimer(lDuration, timerType::singleWav);

        // prepare the next entry
        switch (m_pIott->io_type) {
        case IO_CONT:
            m_pIott++;
            break;
        case IO_LINK:
            m_pIott = m_pIott->io_nextp;
            break;
        case IO_EOT:
            m_pIott = NULL;
            break;
        }
    }

    int CPlayOp::getWavDuration(int hFile, long *plDuration)
    {
        struct _stat buf;
        if (_fstat(hFile, &buf) != 0) {
            (*plDuration) = 1000; // give a default value
            log(3, "CPlayOp::getWavDuration(): _fstat() failed. errno is %d", errno);
            return resultIOERROR;
        }

        // We'll do a simple calculation (with assumptions)
        // Because all WAV files at this time are at 11025 samples per second
        // and 8 bits per sample, all we need to do is divide the size by 11025
        // for the duration.
        (*plDuration) = static_cast<long>((buf.st_size / 11025.0) * 1000);

        return resultSUCCESS;
    }
}

---