---

libdaisy.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 libdaisy.c
 * \author André Lindhjem, Kjetil Holien, Terje Risa & Øyvind Nerbråten
 * \date 21.03.2006
 * 
 * Libdaisy is a toolkit for parsing and playing Daisy Digital Talking Books (DTB).
 */
 
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

#include "libdaisy.h"
#include "control.h"
#include "common.h"
#include "snprintf/snprintf.h"
#include "audio.h"
#include "report.h"

#define DAISYPLAYER_MAGIC_NUMBER 0xC729A4BF



typedef struct {
    void        *data;  /* user-defined pointer to data. this will be availible in all callback functions */
    void        (*cb_daisy_audio_done)  (void *);   /* (data, progress_ms_t);   called when libdaisy are done playing an audio segment */
    void        (*cb_daisy_audio_next)  (void *, unsigned long int);    /* (data, void) called when daisy are playing audio */
    void        (*cb_daisy_text)        (void *, void *);   /* (data, passage); called when daisy have parsed a text-passage */
    void        (*cb_daisy_id)          (void *, void *);   /* (data, id);  called when daisy have parsed an id */
    void        (*cb_daisy_error)       (void *, enum daisy_status, const char *daisy_status_msg);
    void        (*cb_daisy_progress)    (void *, long int); /* (data, progress_ms) */
    
    void *audio_data;   /* data related to audio decoding and playback */
    struct DaisyData *daisy_book_data;
    unsigned int magic; /* magic number that verifies if the struct is valid or not */
    
    pthread_mutex_t daisy_mutex;    /* mutex used in libdaisy.c */

} struct_daisyplayer_t;



/* ************************************************ *
 *          Static function declarations            *
 * ************************************************ */

static void local_cb_daisy_audio_done (daisyplayer_t daisy);

static audio_data_t start_audio (daisyplayer_t  daisy,
                  void (*done) (daisyplayer_t),
                  void (*error) (void *data, enum daisy_status, const char *),
                  void (*progress) (void *data, long int progress_ms));

static void stop_audio (daisyplayer_t   daisy, audio_data_t data);



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

static void local_cb_daisy_audio_done (daisyplayer_t daisy)
{
    int result;
    struct_daisyplayer_t *_daisy = daisy;
    
    _daisy->cb_daisy_audio_done (_daisy->data); /* call the done playing a passage callback function */

    result = daisy_seek (_daisy, DAISY_SEEK_NEXT_PASSAGE);  /* seek to the next passage and continue playing */

    if (result != 1 )
    {
        if (result == 0)
        {
            _daisy->cb_daisy_error (_daisy->data, DAISY_END_OF_BOOK, NULL);
        }   
        else                
        {
            _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_SEEK_FAILED, NULL);
        }
    }
}

static audio_data_t start_audio (daisyplayer_t  daisy,
                  void          (*done)     (daisyplayer_t d),
                  void          (*error)    (void *data, enum daisy_status, const char *daisy_error_msg),
                  void          (*progress) (void *data, long int progress_ms))
{
    audio_data_t ret;
    struct_daisyplayer_t *_daisy = daisy;
    
    ret = audio_initiate (_daisy, done, error, progress);

    if (DEBUG_DAISYPLAYER) report ("control.c: in start_audio", REP_DEBUG);

    if (pthread_create (&_daisy->daisy_book_data->thread_audio, NULL, &audio_thread, ret))
    {
        report ("Error creating audio thread", REP_CRITICAL);
        return NULL; /* fail */
    }
    else
    {
        if (DEBUG_DAISYPLAYER) report ("control.c: audio_thread started", REP_DEBUG);
    }

    return ret; /* succeed */
}

static void stop_audio (daisyplayer_t daisy, audio_data_t data)
{
    struct_daisyplayer_t *_daisy = daisy;
    
    audio_terminate(data);      /* tell audiomodule to terminate and clean up   */
    pthread_cancel (_daisy->daisy_book_data->thread_audio);
}



/* ************************************************** *
 *          Global function definitions               *
 * ************************************************** */
 
daisyplayer_t daisy_init (void *data,
                          void (*l_cb_daisy_audio_done) (void *),                   /* (data, progress_ms_t ), */
                          void (*l_cb_daisy_audio_next) (void *, unsigned long int),/* (data, void), */
                          void (*l_cb_daisy_text)       (void *, void *),           /* (data, passage_t ), */
                          void (*l_cb_daisy_id)         (void *, void *),           /* (data, id_t ) */
                          void (*l_cb_daisy_error)      (void *, enum daisy_status, const char *),
                          void (*l_cb_daisy_progress)   (void *, long int))         /* (data, progress_ms) */
                          
{
    struct_daisyplayer_t *daisy = malloc (sizeof(struct_daisyplayer_t));    /* allocates space for struct daisyplayer */

    daisy->magic = DAISYPLAYER_MAGIC_NUMBER;    /* set magic number */
    
    if (pthread_mutex_init(&daisy->daisy_mutex, NULL) != 0) {
        l_cb_daisy_error (daisy, DAISY_ERROR_MISC_INIT_MUTEX, NULL);
        report ("Could not initialize daisy->daisy_mutex", REP_ERROR);
        return NULL; /* fail */
    }   
    /* store away users data pointer */
    daisy->data = data;

    /* initiates the callback functions */
    daisy->cb_daisy_audio_done  = l_cb_daisy_audio_done;
    daisy->cb_daisy_audio_next  = l_cb_daisy_audio_next;
    daisy->cb_daisy_text        = l_cb_daisy_text;
    daisy->cb_daisy_id          = l_cb_daisy_id;
    daisy->cb_daisy_error       = l_cb_daisy_error;
    daisy->cb_daisy_progress    = l_cb_daisy_progress;
    
    /* initiates the parser and data structure */
    daisy->daisy_book_data = parseInit ();

    /* initiate the audio thread */
    daisy->audio_data = start_audio (daisy, local_cb_daisy_audio_done, daisy->cb_daisy_error, daisy->cb_daisy_progress);
    assert (daisy->magic == DAISYPLAYER_MAGIC_NUMBER);
    return daisy;
}

void daisy_term (daisyplayer_t daisy)
{   
    struct_daisyplayer_t *_daisy = daisy;

    if (DEBUG_DAISYPLAYER) report ("daisy_term\n", REP_DEBUG);
    
    parseTerminate (_daisy->daisy_book_data);   /* deallocates the data structure and cleans up after the parser */

    stop_audio(_daisy, _daisy->audio_data);
    
    _daisy->magic = 0x00000000;
    free (_daisy);      /* frees the daisy struct */
}

int daisy_load (daisyplayer_t daisy, char *path)
{
    int result;
    struct_daisyplayer_t *_daisy = daisy;
    
    if (DEBUG_DAISYPLAYER) report ("daisy_load\n", REP_DEBUG);
    
    stop_audio(_daisy, _daisy->audio_data); _daisy->audio_data = NULL;
    _daisy->audio_data = start_audio(_daisy, local_cb_daisy_audio_done, _daisy->cb_daisy_error, _daisy->cb_daisy_progress);
    
    result = parse (_daisy->daisy_book_data, path);
    if (result != 1)
        return result;
    result = seek (_daisy->daisy_book_data, DAISY_SEEK_NEXT_PASSAGE);
    return result;
}

int daisy_play (daisyplayer_t daisy)
{
    struct_daisyplayer_t *_daisy = daisy;
    unsigned long int duration_ms;
    char audiopath[STRLEN];

    if (DEBUG_DAISYPLAYER) report ("daisy_play\n", REP_DEBUG);
    
    /* check if a daisy dtb is loaded */
    if (_daisy->daisy_book_data->smilHead->next == _daisy->daisy_book_data->smilTail)
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return -1;  
    }

    /* starting audio */
    if (_daisy->daisy_book_data->nodePos->audiofilename != NULL)
    {
        snprintf (audiopath, sizeof (audiopath), "%s%s", _daisy->daisy_book_data->path, _daisy->daisy_book_data->nodePos->audiofilename);
        duration_ms = audio_play (_daisy->audio_data, audiopath, _daisy->daisy_book_data->nodePos->audioStartPos, _daisy->daisy_book_data->nodePos->audioStopPos);
        if ((int) duration_ms == -1)
            return -1;  /* error! */
        _daisy->cb_daisy_audio_next (_daisy->data, duration_ms);    /* we start playing a passage */
    }
    else
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_AUDIO_IN_SEGMENT, NULL);
    }

    /* reporting id and text */
    if (_daisy->daisy_book_data->nodePos->textPassage != NULL && _daisy->daisy_book_data->nodePos->fragmentIdentifier != NULL)
    {
        _daisy->cb_daisy_id (_daisy->data, (void *) _daisy->daisy_book_data->nodePos->fragmentIdentifier);  /* output id */
        _daisy->cb_daisy_text (_daisy->data, (void *) _daisy->daisy_book_data->nodePos->textPassage);   /* output text */
    }
    else
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_TEXT_IN_SEGMENT, NULL);   
    }
    
    return 1;   /* success */
}

int daisy_seek (daisyplayer_t daisy, int seek_option)
{
    struct_daisyplayer_t *_daisy = daisy;
    audio_state_t aState;
    
    if (DEBUG_DAISYPLAYER) report ("daisy_seek\n", REP_DEBUG);

    /*pthread_mutex_lock (&_daisy->daisy_mutex);*/ /* locking mutex */
    if (pthread_mutex_trylock (&_daisy->daisy_mutex) != 0) /* trying to locking mutex, return -1 on failed */
    {
        return -1;
    }
    
    if (DEBUG_THREADS) report ("daisy_seek has daisy_mutex", REP_DEBUG);

    /* check if a daisy dtb is loaded */
    if (_daisy->daisy_book_data->smilHead->next == _daisy->daisy_book_data->smilTail)
    {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return -1;
    }

    /* check the state of the audio engine */
    aState = audio_get_state (_daisy->audio_data);

    if (aState != AUDIO_STATE_STOP) /* don't stop if state already is stopped */
    {
        if (audio_stop (_daisy->audio_data) != 1)   /* try stopping playback */
        {
            pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
            if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
            return -1;
        }
    }

    if (audio_get_state (_daisy->audio_data) == AUDIO_STATE_STOP)
    {
        int ret = seek (_daisy->daisy_book_data, seek_option);

        if (ret != 1)   /* seek if stop was successful */
        {
            pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
            
            if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);

            if (ret == 0)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    } else {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        return -1;
    }

    if (daisy_play(_daisy) != 1)    /* try starting playback */
    {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        return -1;
    }

    pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */

    if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);

    return 1;
}

daisy_position *daisy_get_position (daisyplayer_t daisy)
{
    struct_daisyplayer_t *_daisy = daisy;
    int smilp = 0, nodep = 0;
    daisy_position *position = NULL;
    
    if (DEBUG_DAISYPLAYER) report ("daisy_get_bookmark\n", REP_DEBUG);
    
    /* check if a daisy dtb is loaded */
    if (_daisy->daisy_book_data->smilHead->next == _daisy->daisy_book_data->smilTail)
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return NULL;    
    }
    
    smilp = getSmilPos(_daisy->daisy_book_data);
    nodep = getNodePos(_daisy->daisy_book_data);
    
    if (smilp != -1 && nodep != -1)
    {
        /* store positions if we successful retrieved them both */
        position = (daisy_position *) malloc (sizeof (daisy_position));
        position->smilpos = smilp;
        position->nodepos = nodep;
    } else
        return NULL;

    return position;
}

int daisy_goto_position (daisyplayer_t daisy, daisy_position *position)
{   
    struct_daisyplayer_t *_daisy = daisy;
    audio_state_t aState;

    if (DEBUG_DAISYPLAYER) report ("daisy_goto_bookmark\n", REP_DEBUG);
    
    pthread_mutex_lock (&_daisy->daisy_mutex); /* locking mutex */
    if (DEBUG_THREADS) report ("daisy_seek has daisy_mutex", REP_DEBUG);
    
    /* check if a daisy dtb is loaded */
    if (_daisy->daisy_book_data->smilHead->next == _daisy->daisy_book_data->smilTail)
    {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return -1;
    }
    
    /* check the state of the audio engine */
    aState = audio_get_state (_daisy->audio_data);
    
    if (aState != AUDIO_STATE_STOP) /* don't stop if state already is stopped */
    {
        if (audio_stop (_daisy->audio_data) != 1)   /* try stopping playback */
        {
            pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
            if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
            return -1;
        }
    }
    if (audio_get_state (_daisy->audio_data) == AUDIO_STATE_STOP)
    {
        if (gotoSmilPosition (_daisy->daisy_book_data, position->smilpos) != 1 || gotoNodePosition (_daisy->daisy_book_data, position->nodepos) != 1)   /* jump if stop was successful */
        {
            pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
            if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
            return -1;
        }
    } else {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        return -1;
    }

    if (daisy_play(_daisy) != 1)    /* try starting playback */
    {
        pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
        if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
        return -1;
    }

    pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
    if (DEBUG_THREADS) report ("daisy_seek released_mutex", REP_DEBUG);
    return 1;   
}

int daisy_stop (daisyplayer_t daisy)
{
    int ret = 0;
    struct_daisyplayer_t  *_daisy = daisy;
    if (pthread_mutex_trylock (&_daisy->daisy_mutex) != 0) /* trying to locking mutex, return -1 on failed */
        return -1;
    if (DEBUG_DAISYPLAYER) report ("daisy_stop\n", REP_DEBUG);
    ret =  audio_stop (_daisy->audio_data);
    pthread_mutex_unlock (&_daisy->daisy_mutex); /* unlocking mutex */
    return ret;
}

int daisy_pause (daisyplayer_t daisy)
{
    struct_daisyplayer_t *_daisy = daisy;
    if (DEBUG_DAISYPLAYER) report ("daisy_pause\n", REP_DEBUG);
    return audio_pause (_daisy->audio_data);
}

char* daisy_get_info (daisyplayer_t daisy, int value)
{
    char* returnvalue = NULL;
    
    struct_daisyplayer_t *_daisy = daisy;
    
    /* check if a daisy dtb is loaded */
    if (_daisy->daisy_book_data->smilHead->next == _daisy->daisy_book_data->smilTail)
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return NULL;
    }
    
    /* get title */
    if(value == DAISY_BOOKINFO_TITLETEXT)
    {
        /* checks if the value isn't NULL */
        if(_daisy->daisy_book_data->bookInfo->titleText != NULL)
        {   
            /* malloc thenew string and copy the book info in this string */
            returnvalue = (char *) malloc (strlen ((char *)_daisy->daisy_book_data->bookInfo->titleText)+1);
            strcpy (returnvalue, _daisy->daisy_book_data->bookInfo->titleText);
        }
    }
    /* get title image */
    else if(value == DAISY_BOOKINFO_TITLEIMAGE)
    {
        if(_daisy->daisy_book_data->bookInfo->titleImage != NULL)
        {
            returnvalue = (char *) malloc (strlen ((char *)_daisy->daisy_book_data->bookInfo->titleImage)+1);
            strcpy (returnvalue, _daisy->daisy_book_data->bookInfo->titleImage);
        }       
    }
    /* get total time */
    else if(value == DAISY_BOOKINFO_TOTALTIME)
    {
        if(_daisy->daisy_book_data->bookInfo->totalTime != NULL)
        {
            returnvalue = (char *) malloc (strlen ((char *)_daisy->daisy_book_data->bookInfo->totalTime)+1);
            strcpy (returnvalue, _daisy->daisy_book_data->bookInfo->totalTime);
        }       
    }
    /* unvalid value */
    else return NULL;
    return returnvalue;
}

int daisy_get_chapter_count (daisyplayer_t daisy)
{
    int count = 0;
    struct SmilNode *tmpSmil = NULL;
    struct_daisyplayer_t *_daisy = daisy;
    
    tmpSmil = _daisy->daisy_book_data->smilHead;
    /* check if a daisy DTB is loaded */
    if (tmpSmil->next == _daisy->daisy_book_data->smilTail)
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return -1;
    }
    /* move to the first node */
    tmpSmil = tmpSmil->next; 
    /* count the smil nodes */
    while (tmpSmil != _daisy->daisy_book_data->smilTail)
    {
        count++;
        tmpSmil = tmpSmil->next;
    }
    /* return the counted value */
    return count;
}

char *daisy_get_chapter_info (daisyplayer_t daisy, int num, int option)
{
    int i = 0;
    char *value = NULL;
    struct SmilNode *tmpSmil = NULL;
    struct_daisyplayer_t *_daisy = daisy;
    
    /* check the parameter value num */
    if (num < 1)
        return NULL;
    tmpSmil = _daisy->daisy_book_data->smilHead;
    /* check if a daisy DTB is loaded */
    if (tmpSmil->next == _daisy->daisy_book_data->smilTail)
    {
        _daisy->cb_daisy_error (_daisy->data, DAISY_ERROR_PLAYBACK_NO_DTB_LOADED, NULL);
        return NULL;
    }
    /* move to the gived smil number */
    for (i = 0; i<num && tmpSmil != _daisy->daisy_book_data->smilTail; i++)
    {
        tmpSmil = tmpSmil->next;    
    }
    if (tmpSmil == _daisy->daisy_book_data->smilTail)
        return NULL;
    /* return the value */
    switch (option)
    {
        case DAISY_CHAPTER_TITLE:
            value = tmpSmil->header;
            return value;
            break;
        
        case DAISY_CHAPTER_WEIGHT: /* not implemented yet */
            return NULL;
            break;
            
        default:
            return NULL;    
    }
}

---