---

audio.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2006 by André Lindhjem <belgarat@sdf.lonestar.org>,     *
 *                         Kjetil Holien <kjetil.holien@gmail.com>,        *
 *                         Terje Risa <terje.risa@gmail.com> &             *
 *                         Øyvind Nerbråten <oyvind@nerbraten.com>         *
 *                                                                         *
 *   This program 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.             *
 ***************************************************************************
 *
 * \file audio.c
 * \author André Lindhjem, Kjetil Holien, Terje Risa & Øyvind Nerbråten
 * \date 25.02.2006
 * 
 * Audio module. This handles the task of reading audio files and playing
 * the audio output. It uses a MP3-decoder and libao, and it can easilly be
 * extended with more decoders.
 */


#include <unistd.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <assert.h>
#include <stdbool.h>
#include <sys/time.h>   /* for timeval */

#include "common.h"             /* common project settings */
#include "audio.h"              /* common for all audio */
#include "mp3.h"                /* mp3 decoder */
#include "parsetime.h"          /* converts time-formats */
#include "report.h"             /* reporter class */
#include "snprintf/snprintf.h"  /* printf function */

#ifdef WITH_AAC     /* enable this to build with AAC support. NOTE: AAC support is not yet fully implemented */
#include "aac.h"        /* aac decoder */
#endif  /* WITH_AAC */


#define AUDIO_MAGIC_NUMBER 0x6B2F6EEF   /* magic number. we use this to check that the struct are valid */


/* ************************************************ *
 *          Static function declarations            *
 * ************************************************ */
 
static
bool open_file (struct_audio_data_t *data, const char *fname);

static
audio_file_t get_file_type (const char *file);

static
bool is_new_file (struct_audio_data_t *data);

static
void *audio_decoder (void*);


/* ************************************************ *
 *          Static function definitions             *
 * ************************************************ */

static
bool open_file (struct_audio_data_t *data, const char *fname)
{
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    /* did we already load the file? */
    if ((data->file_name != NULL) && !strcmp (data->file_name, fname)) {
        if (DEBUG_AUDIO) report ("File already loaded", REP_DEBUG);
    }

    else {  /* file is NOT already loaded!
               We'll need to:
               1: free the old mmap
               2: open the new file
               3: create a new mmap */

        if (data->fdm != NULL)  /* 1: Free mmap, clean data */
        {
            /* freeing the mmap before creating a new one */
            if (munmap (data->fdm, data->stat.st_size) == -1)
            {
                data->cb_error (data->daisy, DAISY_ERROR_AUDIO_FREE_MMAP, NULL);
                report ("Unable to free mmap", REP_ERROR);
            }

            if (DEBUG_AUDIO) {
                char rep[STRLEN];
                snprintf (rep, sizeof (rep), "Freed mmap. Pointer: %p, Size: %d", data->fdm, (int) data->stat.st_size);
                report (rep, REP_DEBUG);
            }

            data->fdm = NULL;       /* we have freed the data - don't want an old pointer to point there! */
            data->file_name = NULL; /* this file is no longer in our memory */
            close (data->fd);       /* closing the file before we open a new one */
        }
        
        /* udating the data-struct with the new file_name */
        if (data->file_name != NULL)
            free(data->file_name);
        data->file_name = (char *) malloc (strlen(fname)+1);
        if (data == NULL) {
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_MALLOC, NULL);
            return false;   /* malloc failed */
        }
        strcpy (data->file_name, fname);
        
        /* open the new file */
        if ((data->fd = open (fname, O_RDONLY)) == -1)
        {
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_OPEN, NULL);
            report ("Error opening file", REP_WARNING);
            return false;   /* open file failed */
        }

        /* setting filetype */
        data->prev_file_type = data->file_type;
        data->file_type = get_file_type(fname);

        /* fstating file. this gives us alot of information about
         * the file (we'll use the st_size (filesize) here) */
        if (stat(fname, &data->stat) == -1 || data->stat.st_size == 0)
        {
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_FSTAT, NULL);
            report ("Error fstating file or filesize is 0", REP_WARNING);
            return false;   /* fstat failed */
        }

        /* create a new mmap */
        data->fdm = mmap (0, data->stat.st_size, PROT_READ, MAP_SHARED, data->fd, 0);
        if (data->fdm == MAP_FAILED)
        {
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_CREATE_MMAP, NULL);  /* report error */
            report ("Error mmapping file", REP_WARNING);
            return false;   /* mmap failed */
        }
        
        if (DEBUG_AUDIO)
        {
            char rep[STRLEN];       
            snprintf (rep, sizeof (rep), "mmapped new file. Pointer: %p, size: %d", data->fdm, (int) data->stat.st_size);       
            report (rep, REP_DEBUG);
        }
    }
    return true;
}


static
audio_file_t get_file_type (const char *fname)
{
    assert (fname);
    if (DEBUG_AUDIO) report("Querying file_type. Returning mp3 for now.", REP_DEBUG);
    return AUDIO_FILE_MP3;
}

static
bool is_new_file (struct_audio_data_t *data)
{
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    if (data->prev_file_name != NULL)   /* prev_file_name is already set to a value */
    {
        if (!strcmp (data->prev_file_name, data->file_name))
        {
            return false;   /* the filenames are the same */
        }
        else
        {
            return true;    /* the filenames differ */
        }
    }
    else
    {
        data->prev_file_name = data->file_name;
        return true;
    }
}

static void *audio_decoder (audio_data_t _data)
{
    audio_state_t playing;
    struct_audio_data_t *data = _data;  /* we need to access information in _data */

    assert (data != NULL);  /* checks for conditions that shouldn't ever happen */
    assert (_data != NULL);

    pthread_mutex_lock (&data->mutex);  /* get mutex - we work on "data" */
    if (DEBUG_THREADS) printf ("audio_decoder has mutex\n");
    
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    if (DEBUG_AUDIO) report ("playing file. . ", REP_DEBUG);

    switch (get_file_type(data->file_name)) /* finds out the filetype */
    {
#ifdef WITH_AAC /* do we build with or without AAC support? */
        case (AUDIO_FILE_AAC):
            if (DEBUG_AUDIO) report ("audio.c: audio-file is aac", REP_DEBUG);

            if ((is_new_file (data)) &&
                (data->prev_file_type != AUDIO_FILE_AAC))   /* last file_type was NOT aac */
            {
                if (DEBUG_AUDIO) report ("the last filetype was NOT aac", REP_DEBUG);
                mp3_close (data);   /* close decoder and start a new one */
                aac_initiate (data);
            }
            (void *) aac_play (data);
            break;
#endif  /* WITH_AAC */
        case (AUDIO_FILE_MP3):
            if (DEBUG_AUDIO) report ("audio.c: audio-file is mp3", REP_DEBUG);

            if ((is_new_file (data)) &&
                (data->prev_file_type != AUDIO_FILE_MP3)) /* last file_type was NOT mp3 */
            {
                if (DEBUG_AUDIO) report ("the last filetype was NOT mp3", REP_DEBUG);
                pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
                if (DEBUG_THREADS) printf ("audio_decoder released mutex. calling mp3_init\n");
#ifdef WITH_AAC
                aac_terminate (data);   /* close decoder and start a new one */
#endif  /* WITH_AAC */
                mp3_init (data);
                pthread_mutex_lock (&data->mutex);
                if (DEBUG_THREADS) printf ("audio_decoder after mp3_init has mutex\n");
            }
            pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
            if (DEBUG_THREADS) printf ("audio_decoder released mutex before mp3_play\n");
            mp3_play (data);
            pthread_mutex_lock (&data->mutex);
            if (DEBUG_THREADS) printf ("audio_decoder has mutex after mp3_play\n");
            break;
        case (AUDIO_FILE_WAV):
            report ("wav parsing isn't implemented yet", REP_MESSAGE);
            break;
        case (AUDIO_FILE_UNKNOWN):
        default:        /* This should never happen! */
            assert (0); /* Report where we are and exit the program */
            break;
    }

    if (DEBUG_AUDIO) report ("start_decoder thread exiting", REP_DEBUG);

    playing = data->state;

    data->is_playing = false;               /* we're not playing anymore */
    data->state = AUDIO_STATE_STOP;         /* settings state to stopped */

    data->do_callback_done = true;

    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    if (DEBUG_THREADS) printf ("audio_decoder released mutex\n");
    pthread_exit (0);
}



/* ************************************************** *
 *          Global function definitions               *
 * ************************************************** */

unsigned
long
int audio_play (audio_data_t _data, const char *fname, const char *start, const char *stop)
{
    struct_audio_data_t *data = _data;
    unsigned long int ret;
    
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("audio_play has mutex\n");
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    if (data->state != AUDIO_STATE_STOP) {  /* make sure we are stopped */
        data->cb_error (data->daisy, DAISY_ERROR_AUDIO_NOT_STOPPED, "audio_play called when state is NOT stopped");
        if (DEBUG_AUDIO) report ("audio_play called when state is NOT stopped", REP_ERROR);
        ret = -1;
    }
    else {
        data->progress.seconds  = 0;    /* reset the progress */
        data->progress.fraction = 0;

        ret =           parse_time_get_dur(start, stop);    /* get duration in ms */
        data->start =   parse_time_mad_time_t (start);  /* and set start- and stop-times. */
        data->stop  =   parse_time_mad_time_t (stop);
        
        if (open_file (data, fname) == false) { /* constructing and reporting an error-message */
            char message[STRLEN];
            snprintf (message, sizeof (message), "Could not open file. (%s)", fname);
            report (message, REP_WARNING);
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_OPEN, "could not open audio file");
            return false;
        }

        data->state = AUDIO_STATE_PLAY;     /* set state to playing */
    }   
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    if (DEBUG_THREADS) printf ("audio_play unlocked mutex\n");
    return ret; /* we return the duration of this clip (or -1 if we fail) */
}

int audio_pause (audio_data_t _data)
{
    struct_audio_data_t *data = _data;
    bool playing = NULL;
    audio_state_t state = AUDIO_STATE_NOOP;
    
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("audio_stop has mutex\n");
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    playing = data->is_playing;
    state = data->state;    /* copy data->state to a local variable */
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */

    if (playing)
    {
        if (state == AUDIO_STATE_PAUSE)
        {
            if (DEBUG_AUDIO) report ("unpausing", REP_DEBUG);
            pthread_mutex_lock (&data->mutex);
            if (DEBUG_THREADS) printf ("audio_pause has mutex");
            data->state = AUDIO_STATE_PLAY;
            pthread_cond_signal (&data->unpause_cond);
            pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
        }
        else
        {
            if (DEBUG_AUDIO) report ("pausing", REP_DEBUG);
            pthread_mutex_lock (&data->mutex);
            if (DEBUG_THREADS) printf ("audio_stop has mutex");
            data->state = AUDIO_STATE_PAUSE;
            pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
        }
        return 1;   /* success */
    }
    data->cb_error (data->daisy, DAISY_ERROR_AUDIO_PAUSED_WHILE_NOT_PLAYING, "audio engine was paused while not playing");
    return -1;  /* pause failed */
}

int audio_stop (audio_data_t _data)
{
    struct_audio_data_t *data = _data;
    void *daisy = NULL; /* pointer to daisy struct in case we need to call cb_error */
    void (*cb_error) (void *, enum daisy_status, const char *); /* error callback. this should be defined the same was as in struct_audio_data_t */

    int ret = -1;   /* return value */
    
    if (DEBUG_AUDIO) report ("stopping", REP_DEBUG);
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("audio_stop has mutex\n");   
    assert (data->magic == AUDIO_MAGIC_NUMBER);

    daisy = data->daisy;
    cb_error = data->cb_error;
    
    if (data == NULL) { /* stop are called before we are initialized! (data doesn't exist yet!) */
        pthread_mutex_unlock (&data->mutex);
        if (DEBUG_THREADS) printf ("audio_stop released mutex (data == NULL)\n");   
        cb_error (daisy, DAISY_ERROR_AUDIO_DATA_IS_NULL, "audio data not initialized! (audio.c:audio_stop)");
        pthread_mutex_lock (&data->mutex);
        if (DEBUG_THREADS) printf ("audio_stop has mutex (data == NULL)\n");    
        ret = -1;
    }
    else if (data->state == AUDIO_STATE_PLAY)
    {
        assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */
        data->state = AUDIO_STATE_STOP;
        while (data->is_playing)
        {
            pthread_mutex_unlock (&data->mutex);
            usleep(500);
            pthread_mutex_lock (&data->mutex);
            
        }

        ret = 1;    /* stop succeeds */
    }
    else {  /* we can't stop if we aren't currently playing! */
        assert (cb_error == data->cb_error);
        pthread_mutex_unlock (&data->mutex);
        if (DEBUG_THREADS) printf ("audio_stop released mutex (stop called when not currently playing)\n"); 
        cb_error (daisy, DAISY_ERROR_AUDIO_STOPPED_WHILE_NOT_PLAYING, "stop called while we're not playing (audio.c:audio_stop)");
        pthread_mutex_lock (&data->mutex);
        if (DEBUG_THREADS) printf ("audio_stop has mutex (stop called when not currently playing)\n");
        ret = -1;   /* error stopping */
    }

    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    if (DEBUG_THREADS) printf ("audio_stop released mutex\n");
    return ret;
}

int callback (audio_data_t _data, long int progress_ms)
{
    struct_audio_data_t *data = _data;
    
    int ret = 0;    /* default return value */
    void (*progress_callback) (void *, long int);

    pthread_mutex_lock (&data->mutex);
    /*if (DEBUG_THREADS) printf ("audio_callback has mutex\n");*/
    assert (data != NULL);
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    if (data->state == AUDIO_STATE_PAUSE)
        pthread_cond_wait (&data->unpause_cond, &data->mutex);

    if (data->state == AUDIO_STATE_STOP) {
        if (DEBUG_AUDIO) report ("callback stopping audio decoder", REP_DEBUG);
        ret = -1;   /* -1 tells the decoder to stop */
    }
    
    progress_callback = data->cb_progress;  /* copy progress callback to a local function pointer (data must be mutex locked) */
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    /*if (DEBUG_THREADS) printf ("audio_callback released mutex\n");*/

    progress_callback (data->daisy, progress_ms);   /* call progress callback */
    return ret;
}

void audio_terminate (audio_data_t _data)
{
    struct_audio_data_t *data = _data;
    
    /* stopping audio first */
    if (audio_get_state(data) != AUDIO_STATE_STOP) audio_stop (data);

    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("audio_terminate has mutex\n");

    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

/*  NOTE: We call audio_stop above rather than signaling audio_thread directly..

    if (data->state != AUDIO_STATE_STOP) {
        data->state = AUDIO_STATE_STOP;
        pthread_cond_wait(&data->stopped_cond, &data->mutex);
    }*/

    /* *********************************************** *
     *  By this point, audio_thread should be stopped  *
     *  and data should be rady to be freed            *
     * *********************************************** */

    switch (data->file_type)    /* call the correct decoder terminate-function */
    {
        case (AUDIO_FILE_MP3):
            mp3_close(data);
            break;
        case (AUDIO_FILE_AAC):
#ifdef WITH_AAC
            aac_terminate (data);
#endif  /* WITH_AAC */
            break;
        case (AUDIO_FILE_WAV):
/*              wav_terminate (data); */
            break;
        default:
            break;
    }

    /* Attempting to free mmap */
    if (data->fdm != NULL) {    /* if data->fdm is null, no file is read into memory and we won't have to free anything */
        if (munmap (data->fdm, data->stat.st_size) == -1) {
            data->cb_error (data->daisy, DAISY_ERROR_AUDIO_FREE_MMAP, NULL);
            report ("Error freeing mmap", REP_MESSAGE);
        }
    }

    close (data->fd);   /* closing the file */

    munmap (data->fdm, data->stat.st_size); /* free the mmap'ed audio file */

    free (data->file_name); /* release space allocated for the filename */

    data->magic = 0x00000000;   /* resetting magic number - we can't use struct anymore! */

    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    if (DEBUG_THREADS) printf ("audio_terminate released mutex\n");
    if (data->mp3_dither != NULL) {
        free (data->mp3_dither);
        data->mp3_dither = NULL;
    }
    free (data);    /* Free data struct */
}

audio_data_t audio_initiate (daisyplayer_t _daisy,
                            void (*done) (daisyplayer_t d),
                            void (*error) (void *data, enum daisy_status status, const char *daisy_status_msg),
                            void (*progress) (void *data, long int progress_ms))
{
    struct_audio_data_t *data = (struct_audio_data_t *) malloc (sizeof (struct_audio_data_t));
    if (data == NULL) {
        error (data, DAISY_ERROR_AUDIO_INITIATE_DATA, NULL);
        report ("Cannot malloc size for data", REP_ERROR);
        return NULL;    /* fail */
    }

    data->magic = AUDIO_MAGIC_NUMBER;   /* set magic number */
    assert (data->magic == AUDIO_MAGIC_NUMBER);

    /* And setting some values to safe defaults */
    data->fd = -1;
    data->fdm = NULL;
    data->file_name = NULL;
    data->prev_file_name = NULL;

    data->mp3_dither = NULL;
    
    data->file_type = AUDIO_FILE_UNKNOWN;
    data->prev_file_type = AUDIO_FILE_UNKNOWN;

    data->state = AUDIO_STATE_STOP;     /* default state is stopped */
    data->is_playing = false;
    
    /* callback functions */    
    data->cb_playing_done = done;   /* callback function. playback_done () should
                                       be called whenever we're done playing
                                       a segment */
    data->do_callback_done = false;

    data->cb_error = error;         /* callback function. cb_error () should
                                       be called when an error occur. */

    data->cb_progress = progress;   /* callback function. cb_progress are called during playback */

    data->daisy = _daisy;           /* we keep a pointer to the main daisy struct */

    /* Setting up some thread data */
    if (pthread_cond_init(&data->unpause_cond, NULL) != 0) {
        data->cb_error (data->daisy, DAISY_ERROR_AUDIO_INITIATE_DATA, NULL);
        report ("Could not initialize data->unpause_cond", REP_ERROR);
        return NULL; /* fail */
    }
    if (pthread_mutex_init(&data->mutex, NULL) != 0) {
        data->cb_error (data->daisy, DAISY_ERROR_AUDIO_INITIATE_DATA, NULL);
        report ("Could not initialize data->mutex", REP_ERROR);
        return NULL; /* fail */
    }

    if (DEBUG_AUDIO) report ("data struct initialized", REP_DEBUG);

    return data;
}

void *audio_thread (void *_data)
{
    struct_audio_data_t *data = (struct_audio_data_t *) _data;

    pthread_t audio_decoder_thread;
    void (*cb_playing_done) (daisyplayer_t daisy);  /* pointer to callback function */
    audio_state_t state;
    bool playing;
    bool exit;
    bool l_do_callback_done;
    
    pthread_mutex_lock (&data->mutex);
    /*if (DEBUG_THREADS) printf ("audio_thread has mutex\n");*/
    assert (data->magic == AUDIO_MAGIC_NUMBER); /* check magic number */

    data->is_playing = false;
    data->state = AUDIO_STATE_STOP;
    
    cb_playing_done = data->cb_playing_done;

    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    /*if (DEBUG_THREADS) printf ("audio_thread released mutex\n");*/

    exit = false;
    while (!exit)
    {
        pthread_mutex_lock (&data->mutex);
        /*if (DEBUG_THREADS) printf ("audio_thread loop has mutex\n");*/
        state   = data->state;
        playing = data->is_playing;
        l_do_callback_done = data->do_callback_done;

        if (l_do_callback_done) {           
            data->do_callback_done = false;
            pthread_mutex_unlock (&data->mutex);
            cb_playing_done (data->daisy);
            pthread_mutex_lock (&data->mutex);
        }
        
        /* by this point, the mutex SHOULD be unlocked */
        if (state == AUDIO_STATE_PLAY)
        {
            if (!playing)
            {
                /*if (DEBUG_AUDIO) report ("audio_thread: starting start_decoder thread", REP_DEBUG);*/
                /*if (DEBUG_THREADS) printf ("audio_thread playing has mutex\n");*/
                data->is_playing = true;
                pthread_create(&audio_decoder_thread, NULL, &audio_decoder, data);
                pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);   /* set cancel type. this thread should be canceled at any time and not just on cancellation points */
                /*if (DEBUG_THREADS) printf ("audio_thread playing released mutex\n");*/
            }
        }
        
        /* by this point, the mutex SHOULD be unlocked */
        
        else if (state == AUDIO_STATE_STOP)
        {
            if (playing)
            {
                if (DEBUG_AUDIO) report ("audio_thread: stopping start_decoder thread", REP_DEBUG);
                if (DEBUG_THREADS) printf ("audio_thread stop has mutex\n");
                data->is_playing = false;               /* we're not playing anymore */
                pthread_cancel (audio_decoder_thread);  /* stopping thread */
                if (DEBUG_THREADS) printf ("audio_thread stop released mutex\n");
            }
        }
        pthread_mutex_unlock (&data->mutex);
        /* by this point, the mutex SHOULD be unlocked */
        usleep (500);   /* don't throttle the cpu */

        if (data->magic != AUDIO_MAGIC_NUMBER) {    /* data struct is not intact - exit */
            exit = true;
        }
    }
    pthread_exit(NULL);
}

audio_state_t audio_get_state (audio_data_t _data)
{
    struct_audio_data_t *data = _data;
    audio_state_t state;
    
    pthread_mutex_lock (&data->mutex);
    state = data->state;
    pthread_mutex_unlock (&data->mutex);

    return state;
}

---