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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SDLaudioIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: SDLaudioIO.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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

// SDLaudioIO.cpp: Implementing the Class SDLaudioIO.
//

#include "SDLaudioIO.hpp"

#include <stdio.h>
#include <stdlib.h>
#ifndef WINCE
#include <signal.h>
#endif



/**********************************************/
SDLaudioIO::SDLaudioIO(AudioESInfo *es, ESSynchronizer *ess) : AudioIO(es, ess) {
  initialized = false;
  requestUnpauseESS = false;
  is = NULL;
}

/**********************************************/
SDLaudioIO::~SDLaudioIO() {
        SDL_CloseAudio();       
}


/**********************************************/
/* packet queue handling */
void SDLaudioIO::packet_queue_init() {
    memset(&(is->audioq), 0, sizeof(PacketQueue));
#ifndef WINCE
    is->audioq.mutex = SDL_CreateMutex();
    is->audioq.cond = SDL_CreateCond();
#else
        is->audioq.mutex = new VMutex();
        is->audioq.mutex->initialize("audioq.mutex");

        is->audioq.cond = new VCondition();
        is->audioq.cond->initialize();
#endif
}


/**********************************************/
/* we need to clear also is->audio_pkt,
 * because is->audio_pkt.data points to a buffer
 * that will be deleted by this function!
 */
void SDLaudioIO::packet_queue_clear() {
        APacketList *pkt, *pkt1;
        
        SDL_LockAudio();
#ifndef WINCE
        SDL_LockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->lock();
#endif
        for(pkt = is->audioq.first_pkt; pkt != NULL; pkt = pkt1) {
                pkt1 = pkt->next;
                delete pkt->pkt.data;
                delete pkt;
        }
        is->audioq.first_pkt = NULL;
        is->audioq.last_pkt = NULL;
        is->audioq.nb_packets = 0;
        is->audioq.size = 0;
        is->audio_pkt.size = 0;
        is->audio_pkt.pts = 0;
        is->audio_pkt.data = NULL;
        is->audio_pkt_index = 0;
#ifndef WINCE
        SDL_UnlockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->release();
#endif
        SDL_UnlockAudio();
}


/**********************************************/
void SDLaudioIO::packet_queue_end() {
        packet_queue_clear();
#ifndef WINCE
        SDL_DestroyMutex(is->audioq.mutex);
        SDL_DestroyCond(is->audioq.cond);
#else
        is->audioq.mutex->destroy();
        is->audioq.cond->destroy();
#endif
}


/**********************************************/
int SDLaudioIO::packet_queue_put(APacket *pkt) {
        APacketList *pkt1;
        
        pkt1 = new APacketList;
        if (!pkt1)
                return -1;
        pkt1->pkt = *pkt;
        pkt1->next = NULL;
        
#ifndef WINCE
        SDL_LockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->lock();
#endif
        
        if (!is->audioq.last_pkt)
                
                is->audioq.first_pkt = pkt1;
        else
                is->audioq.last_pkt->next = pkt1;
        is->audioq.last_pkt = pkt1;
        is->audioq.nb_packets++;
        is->audioq.size += pkt1->pkt.size;
#ifndef WINCE
        SDL_CondSignal(is->audioq.cond);
#else
        is->audioq.cond->signal();
#endif
        
#ifndef WINCE
        SDL_UnlockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->release();
#endif
        return 0;
}


/**********************************************/
void SDLaudioIO::packet_queue_abort() {
#ifndef WINCE
        SDL_LockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->lock();
#endif
        
        is->audioq.abort_request = 1;
  
#ifndef WINCE
        SDL_CondSignal(is->audioq.cond);
#else
        is->audioq.cond->signal();
#endif
        
#ifndef WINCE
        SDL_UnlockMutex(is->audioq.mutex);
#else
        is->audioq.mutex->release();
#endif
}


/**********************************************/
/* return < 0 if aborted, 0 if no packet and > 0 if packet.  
 * This is called by sdl_audio_callback(), so we should avoid
 * blocking forever, as this could lead to a deadlock with a
 * thread calling SDLaudioIO::close() when the DataChannel
 * thread is also blocked.
 */
int SDLaudioIO::packet_queue_get(PacketQueue *q, APacket *pkt, int block) {
        APacketList *pkt1;
        int ret;
        
#ifndef WINCE
        SDL_LockMutex(q->mutex);
#else
        q->mutex->lock();
#endif
        
        for(;;) {
                if (q->abort_request) {
                        ret = -1;
                        break;
                }
                
                pkt1 = q->first_pkt;
                if (pkt1) {
                        q->first_pkt = pkt1->next;
                        if (!q->first_pkt)
                                q->last_pkt = NULL;
                        q->nb_packets--;
                        q->size -= pkt1->pkt.size;
                        *pkt = pkt1->pkt;
                        delete pkt1;
                        ret = 1;
                        break;
                } else if (!block) {
                        ret = 0;
                        break;
                } else {
                        // block at most 100 ms
#ifndef WINCE
                        ret = SDL_CondWaitTimeout(q->cond, q->mutex, 100);
#else
                        dprintf_full("SDLaudioIO: packet_queue_get() sleeping\n");
                        Sleep(100);
                        q->cond->condWait();
                        ret = 1;
#endif
                        if (ret == SDL_MUTEX_TIMEDOUT) {
                                ret = 0;
                                break;
                        } else if (ret < 0)     // error
                                break;
                        // else condition was signalled, continue
                }
        }
#ifndef WINCE
        SDL_UnlockMutex(q->mutex);
#else
        q->mutex->release();
#endif
        return ret;
}


const char *SDLaudioIO::get_sdl_audio_state() const {
  static char *stat[] = {"unknown", "stopped", "paused", "playing"};
  char *retval = stat[0];
  SDL_audiostatus status = SDL_GetAudioStatus();
  switch(status) {
  case SDL_AUDIO_STOPPED:
    retval = stat[1];
    break;
  case SDL_AUDIO_PAUSED:
    retval = stat[2];
    break;
  case SDL_AUDIO_PLAYING:
    retval = stat[3];
    break;
  }
  return retval;
}


/**********************************************/
/* prepare a new audio buffer */
void sdl_audio_callback(void *opaque, u8 *stream, int length) {
  AudioState *is = (AudioState *)opaque;
  SDLaudioIO *aud = is->selfClass;
  APacket *pkt = &is->audio_pkt;
  int len = length;
  int len1;
  bool pempty = false;          // packet queue empty?
        
  while (len > 0) {
    // is->audio_pkt fully delivered to SDL?
    if (is->audio_pkt_index >= pkt->size) {
      /* delete old packet data */
      if (pkt->size > 0 && pkt->data)
                                delete pkt->data;
      pkt->size = 0;
      is->audio_pkt_index = 0;
      if (aud->packet_queue_get(&is->audioq, pkt, 1) <= 0) {
                                /* no packet available or error, just output silence */
                                dprintf_full("SDLaudioIO: sdl_audio_callback() packet queue empty or error\n");
                                memset(stream, 0, len);
                                pempty = true;
                                break;                  // leave pkt->pts untouched
      }
    }
    len1 = pkt->size - is->audio_pkt_index;
    if (len1 > len)
      len1 = len;
    memcpy(stream, pkt->data + is->audio_pkt_index, len1);
    len -= len1;
    stream += len1;
    is->audio_pkt_index += len1;
  }
        
  dprintf_full("SDLaudioIO: sdl_audio_callback() copied %d bytes to SDL audio buffer, "
                                                         "audio_pkt_index = %d, pkt->size = %d, PTS = %u\n",
                                                         length, is->audio_pkt_index, pkt->size, ((u32)pkt->pts));


  dprintf_full("SDLaudioIO: sdl_audio_callback() pemtpy is %d, aud->lastpts=%ld, pkt->pts=%ld", pempty, aud->getLastPTS(), (long int)pkt->pts);
        
  if (!pempty) {
#ifndef WINCE
    if ((unsigned)aud->getLastPTS() != pkt->pts) {
#endif
      if (aud->getESSync())
                                aud->getESSync()->getGlobalTimer()->adjustToTS(pkt->pts, is->ticks_per_second);
      /* if first packet, unpause video (after adjusting the GlobalTimer!) */
      if (aud->requestUnpauseESS && aud->getESSync()) {
                                dprintf_full("SDLaudioIO: sdl_audio_callback() unpausing ESSychronizer\n");
                                aud->requestUnpauseESS = false;
                                aud->getESSync()->setPaused(false);
      }
      aud->setLastPTS(pkt->pts);
#ifndef WINCE
    }
#endif
  }

}


/**********************************************/
int SDLaudioIO::initialize()
{
  if (initialized)
    return 0;
  dprintf_full("SDLaudioIO::initialize() Using SDL audio library\n");

        if(es) {
                int flags;
    
                flags = SDL_INIT_AUDIO | SDL_INIT_TIMER;
                
//#ifndef WIN32
                flags |= SDL_INIT_EVENTTHREAD; /* Not supported on win32 */
//#endif
                
                if (SDL_Init (flags)) {
                        dprintf_err("Could not initialize SDL - exiting\n");
                        ::exit(1);
                }
                
                is = new AudioState;
                if (!is){
                        dprintf_err("Error in Allocating AudioState\n");
                        return -1;
                }
                is->selfClass = this; //get obj-ptr for static SDL functions
                is->abort_request = 0;
                is->audio_pkt_index = 0;
                is->audio_pkt_time_increment = 0;
                is->ticks_per_second = es->getMediaTimeScale();
                if (!is->ticks_per_second)
                  is->ticks_per_second = 90000;
                is->queue_full_delay = 0;
                memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
                packet_queue_init();
    
                SDL_AudioSpec wanted_spec;
                
                /* prepare audio output */
                wanted_spec.freq = es->getSampleRate();
                
                wanted_spec.format = AUDIO_S16SYS;
                wanted_spec.channels = es->getAudioChannels();
                wanted_spec.silence = 0;
                wanted_spec.samples = SDL_AUDIO_BUFFER_SAMPLES;
                wanted_spec.callback = sdl_audio_callback;
                wanted_spec.userdata = is;
                if (SDL_OpenAudio(&wanted_spec, &is->spec) < 0) {
                        dprintf_err("SDLaudioIO::initialize() SDL_OpenAudio: %s\n",
                                    SDL_GetError());
                        return -1;
                }
                
                SDL_PauseAudio(0);
                
                dprintf_full("SDLaudioIO::initialize() Freq =  %d (wanted %d) Channels = %u "
                             "Samples = %u Buffer Size = %u Format = %u\r\n", 
                             is->spec.freq, wanted_spec.freq, is->spec.channels, is->spec.samples,
                             is->spec.size, is->spec.format);
        }
        else {
                dprintf_err("SDLaudioIO::initialize() failed no ES\r\n");
                return -1;
        }
        initialized = true;
        return 0;
}

int SDLaudioIO::restartSDLThread()
{
  if (!initialized) {
    initialize();
  } else {
    SDL_AudioSpec wanted_spec = is->spec;
    SDL_CloseAudio();
    if (SDL_OpenAudio(&wanted_spec, &is->spec) < 0) {
      dprintf_err("SDLaudioIO::restartSDLThread() SDL_OpenAudio: %s\n",
                  SDL_GetError());
      return -1;
    }
    dprintf_full("SDLaudioIO::restartSDLThread() Freq =  %d Channels = %u "
                 "Samples = %u Buffer Size = %u Format = %u\r\n", 
                 is->spec.freq, is->spec.channels, is->spec.samples,
                 is->spec.size, is->spec.format);
    SDL_PauseAudio(0);
  }
  return 0;
}

/**********************************************/
Frame * SDLaudioIO::getFrame() {
        dprintf_full("SDLaudioIO::getFrame NOT IMPLEMENTED!\n");

#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

        return NULL;
}



/**********************************************/
int SDLaudioIO::writeFrame(Frame * frm, ESInfo *out_es) {
  int ntrials = 20;             // number of delay calls when queue is full
  int i;

  if (!initialized) {
    if(initialize() < 0) {
      dprintf_err("SDLaudioIO::writeFrame() Error in initializing\n");
      return 0;
    }
  }
  if (!frm->getAU()->size) {
    return 0;
  }
  if(firstFrame) {
    firstFrame = false;
  }
  num_frames++;

  if (!is->audio_pkt_time_increment) {
    u32 bits_per_second = es->getSampleRate() * es->getBitsPerSample() * es->getAudioChannels();
    if (bits_per_second) {
      is->audio_pkt_time_increment = frm->getAU()->size * 1000 * 8 / bits_per_second;
          dprintf_full("SDLaudioIO::writeFrame(): is->audio_pkt_time_increment = %d, AUsize = %d, bps = %d", is->audio_pkt_time_increment, frm->getAU()->size, bits_per_second);
        }
    else
      is->audio_pkt_time_increment = 1000;
    /* compute blocking delay (in ms) when queue is full;
     * (ntrials * delay) >= audio_pkt_time_increment
     * is minimally required to avoid loosing packets.
     */
    //is->queue_full_delay = is->audio_pkt_time_increment * 2 / ntrials;
        is->queue_full_delay = is->audio_pkt_time_increment * 2;
        if (is->audio_pkt_time_increment > 50 || is->audio_pkt_time_increment <= 0) is->audio_pkt_time_increment = 50; //100 msecs

    dprintf_full("SDLaudioIO::writeFrame() pkt_time_increment = %u ms, "
                 "queue_full_delay = %u ms\n",
                 is->audio_pkt_time_increment, is->queue_full_delay);
  }

  if(IO::getState() != IO::MUTED) {
    assert(frm->getAU()->payload != NULL); 
    /* work around a problem on Linux where the SDL audio thread happens to die 
     * unexpectedly 
     */
    if (SDL_GetAudioStatus() == SDL_AUDIO_STOPPED) {
      dprintf_small("SDLaudioIO::writeFrame() detected dead SDL thread - re-starting\n");
      restartSDLThread();
    }

    /* if the queue is full, block for a finite period of time */
    for (i = ntrials; is->audioq.size > SDL_MAX_AUDIOQ_SIZE && i > 0; i--) {
      dprintf_full("SDLaudioIO::writeFrame() Queue Full! aqsize=%d max=%d i=%d\n", is->audioq.size, SDL_MAX_AUDIOQ_SIZE, i);
      SDL_Delay(is->queue_full_delay);
    }

    if (is->audioq.size > SDL_MAX_AUDIOQ_SIZE) {
      dprintf_small("SDLaudioIO::writeFrame() Queue full - dropping packet!\n"
                    "    SDL audio state = %s\n",
                    get_sdl_audio_state());
      return 0;
    }

    /* enqueue new packet */
    APacket pkt1, *pkt = &pkt1;
    pkt->size = frm->getAU()->size; //size
    pkt->pts = frm->getAU()->cts; //presentation timestamp
    pkt->data = new u8[pkt->size];
                
    memcpy(pkt->data, frm->getAU()->payload, pkt->size);

    dprintf_full("SDLaudioIO::writeFrame() PTS %u SIZE %i audioq size = %i\n",
                 ((u32)pkt->pts), pkt->size, is->audioq.size);

    if(packet_queue_put(pkt) < 0) {
      dprintf_err("SDLaudioIO::writeFrame() Error in putting packet into Queue\n");
      delete pkt->data;
      return 0;
    }
  }

#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

  return 1;
}


/**********************************************/
/* we should NOT initialize() here as ESInfo data
 * may not be available yet
 */
bool SDLaudioIO::open() {
        if (essync) {
                                        dprintf_full("SDLaudioIO::open() SDL audio state = %s, PAUSING ESSynchronizer\n",
                                                                                         get_sdl_audio_state());
                                        essync->setPaused(true);
                                        requestUnpauseESS = true; // no locking, as the SDL thread is not running yet
                                }
                                initialized = false;
                                setState(OPEN);
                                return true;
}


/**********************************************/
int SDLaudioIO::getPacketsInQueue()
{
        int packetsInQueue = 0;

#ifndef WINCE
                SDL_LockMutex(is->audioq.mutex);
#else
                is->audioq.mutex->lock();
#endif
        

                packetsInQueue = is->audioq.nb_packets;
  

#ifndef WINCE
                SDL_CondSignal(is->audioq.cond);
#else
                is->audioq.cond->signal();
#endif
        
#ifndef WINCE
                SDL_UnlockMutex(is->audioq.mutex);
#else
                is->audioq.mutex->release();
#endif

                dprintf_full("SDLaudioIO::close() packets in queue: %d\n", packetsInQueue);
                return packetsInQueue;
}

/**********************************************/
bool SDLaudioIO::close(bool immediate) {
        
        if (!immediate) {
                while (this->getPacketsInQueue() > 0) msleep(500);
        }

        if(initialized) {
                packet_queue_abort(/*&is->audioq*/);
                SDL_CloseAudio();
                packet_queue_end(/*&is->audioq*/);
                if(is)
                        delete is;
        }
        setState(CLOSED);
        dprintf_full("SDLaudioIO::close() SDL audio state after SDL_CloseAudio() = %s\n",
                     get_sdl_audio_state());
        initialized = false;
        return true;
}


/**********************************************/
IO::State SDLaudioIO::pause() {
        /* pause audio callback processing, will also protect requestUnpauseESS */
        SDL_PauseAudio(1);
        dprintf_full("SDLaudioIO::pause() SDL audio state after SDL_PauseAudio(1) = %s\n",
                                                         get_sdl_audio_state());
        return setState(PAUSED);
}


/**********************************************/
IO::State SDLaudioIO::play(double prefetchTime) {
        if(IO::getState() == MUTED)
                return setState(OPEN);
        
        if (essync) {
          essync->setPaused(true); // for A/V sync, unpaused by sdl_audio_callback()
          requestUnpauseESS = true;
        }
        if (initialized) {
          SDL_PauseAudio(0);
          dprintf_full("SDLaudioIO::play() SDL audio state after SDL_PauseAudio(0) = %s\n",
                                                                 get_sdl_audio_state());
          /* work around a problem on Linux, where SDL_PauseAudio(0)
           * leaves SDL audio status at STOPPED (meaning the SDL audio thread
           * has already terminated).
           */
          if (SDL_GetAudioStatus() != SDL_AUDIO_PLAYING) {
            dprintf_full("SDLaudioIO::play() detected dead SDL audio thread - re-starting\n");
            restartSDLThread();
          }
        }
        return setState(OPEN);
}


IO::State SDLaudioIO::mute() {
        return setState(MUTED);
}


void SDLaudioIO::clearBuffer() {
  packet_queue_clear();
}

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