Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

DSPaudioIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: DSPaudioIO.cpp                                                *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program 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 General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef WIN32


// DSPaudioIO.cpp: Implementing the Class DSPaudioIO.
//

#include "DSPaudioIO.hpp"
#include "AudioESInfo.hpp"
#include "Frame.hpp"
#include "io/Rtp.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>



// Audio.cpp: Implementing the Class DSPaudioIO.
//

#include "DSPaudioIO.hpp"
#include "ESInfo.hpp"
#include "Frame.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
extern "C" {
#include "SLASH_dev_SLASH_audio.h"
}

#define AUDIO_FILLSZ 4608

int fd;

static u8 *audio_chunk;
static u32 audio_len;

DSPaudioIO::DSPaudioIO(AudioESInfo *es, ESSynchronizer *ess, bool enableHeadphones) : AudioIO(es, ess) {
        requestUnpauseESS = false;
        this->enableHeadphones = enableHeadphones;
}


DSPaudioIO::~DSPaudioIO() {
}


int DSPaudioIO::initialize() {

        if(es) {
                dprintf_full("DSPaudioIO::initialize with %i Hz (samples/sec) and %i channels\n", es->getSampleRate(), es->getAudioChannels());
                fd = ::open(AUDIO_DEVICE, O_WRONLY);
                if (fd == -1) {
                        dprintf_err("DSPaudioIO::initialize Error opening AUDIO_DEVICE\n");
                        return -1;
                }
                
                if (dsp_audio_init(fd, es->getSampleRate(), es->getAudioChannels(), enableHeadphones) == -1) {
                        ::close(fd);
                        dprintf_err("DSPaudioIO::initialize Error in initializing audio\n");
                        return -1;
                }
                
        }
        else {
                dprintf_err("DSPaudioIO::initialize() failed no ES\r\n");
        }
        
return 0;
}


Frame * DSPaudioIO::getFrame() {
        return NULL;
}


int DSPaudioIO::writeFrame(Frame * frm, ESInfo *out_es) {
        dprintf_full("DSPaudioIO::writeFrame %i bytes, using %s audio device \n",frm->getAU()->size, AUDIO_DEVICE);
  if (firstFrame) {
    firstFrame = false;
    if(initialize() < 0) {
      dprintf_err("DSPaudioIO::writeFrame Error in initializing\n");
      return 0;
    }
  }
  
  audio_chunk = frm->getAU()->payload;
  audio_len = frm->getAU()->size;
          assert(audio_chunk != NULL);
  if(getState() != MUTED) {
                if (audio_buffer(fd, audio_chunk, audio_len ) < 0) {
                  dprintf_err("DSPaudioIO:: Error in Playing audio chunk\n");
                }
  }
        if (getESSync())
                getESSync()->getGlobalTimer()->adjustToTS(frm->getAU()->cts, es->getMediaTimeScale());
        if (requestUnpauseESS && getESSync()) {
                dprintf_full("DSPaudioIO: unpausing ESSychronizer\n");
                requestUnpauseESS = false;
                getESSync()->setPaused(false);
        }


        //#ifdef _POSIX_PRIORITY_SCHEDULING
        //  sched_yield(); //this is necessary to give parallel getFrames a chance
        //#endif
  return 1; //one frame written
}


bool DSPaudioIO::open() {
        if (getESSync()) {
                dprintf_full("DSPaudioIO::open()PAUSING ESSynchronizer\n");
                getESSync()->setPaused(true);
                requestUnpauseESS = true; // no locking, as the SDL thread is not running yet
        }
        setState(OPEN);
        return true;
}


bool DSPaudioIO::close(bool immediate) {
        
        ::close(fd);
        
        destroy();
        setState(CLOSED);
        //::exit(0);
        return true;
}

#endif /* WIN32 */

© ViTooKi 2003 :: [Lite version] Created with Doxygen