---

mp3.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 mp3.c
 * \author André Lindhjem, Kjetil Holien, Terje Risa & Øyvind Nerbråten
 * \date 15.02.2006
 * 
 * This code uses libmad0 to do mp3 decoding, and libao to do the audio output.
 * It borrows code from / are inspired by mpg321 and minimad.c.
 */
 
/* * * Resources:
 * * * A good description of how mad works (the closest thing to an API we'll get?).
 * * * * http://trac.videolan.org/vlc/file/tags/v0_3_0/plugins/mad/API?rev=6952
 * * * http://www.mars.org/mailman/public/mad-dev/2001-August/000338.html
 * * * http://www.mars.org/mailman/public/mad-dev/2001-May/000244.html
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <mad.h>
#include <stdbool.h>
#include <pthread.h>
#include <assert.h>

#include "common.h"     /* common project settings */
#include "mp3.h"        /* handles mp3 decoding */
#include "daisylibao.h" /* libao wrapper for the daisyplayer */
#include "audio.h"      /* audio interface */
#include "report.h"     /* report method */
#include "snprintf/snprintf.h"
#include "parsetime.h"



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

static
enum                mad_flow input      (audio_data_t _data, struct mad_stream *stream);

static
__inline__
signed long audio_linear_dither (unsigned int bits, mad_fixed_t sample,
                                 struct audio_dither *dither);

static
int                 mp3_decode          (struct_audio_data_t *data);

static
__inline__
unsigned long       prng                (unsigned long state);

static
enum                mad_flow output     (audio_data_t _data, struct mad_header const *header, struct mad_pcm *pcm);

static
enum                mad_flow error      (audio_data_t _data, struct mad_stream *stream, struct mad_frame *frame);

static
enum                mad_flow header     (audio_data_t _data, struct mad_header const *header);

static
struct audio_dither * init_dither (void);

static
void reset_dither (struct audio_dither *dither);

static
void free_dither (struct audio_dither *dither);



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

static
enum mad_flow input (audio_data_t data,
                     struct mad_stream *stream)
{
    struct_audio_data_t *_data = data;
    
    pthread_mutex_lock (&_data->mutex);
    if (DEBUG_THREADS) printf ("mp3_input has mutex\n");

    if (!_data->buffer.buffer_length) {
        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        if (DEBUG_THREADS) printf ("mp3_input released mutex - stopping\n");
        return MAD_FLOW_STOP;
    } else {

        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        if (DEBUG_THREADS) printf ("mp3_input released mutex before mad_stream_buffer\n");
        /*TODO: We'll probably need to copy out _data->buffer.buffer_start, _data->buffer.buffer_length while we actually have the mutex */
        mad_stream_buffer (stream, _data->buffer.buffer_start, _data->buffer.buffer_length);
/*      while (pthread_mutex_trylock (&data->mutex) == EBUSY) { printf ("mp3 input: retrying mutex after mad_stream_buffer\n"); }*/ /* get mutex - we work on "data" */     
        pthread_mutex_lock (&_data->mutex);
        if (DEBUG_THREADS) printf ("mp3_input got mutex after mad_stream_buffer\n");
        _data->buffer.buffer_length = 0;
        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        if (DEBUG_THREADS) printf ("mp3_input released mutex - continuing\n");
        return MAD_FLOW_CONTINUE;
    }
}

static
__inline__
signed long audio_linear_dither (unsigned int bits, mad_fixed_t sample,
                                 struct audio_dither *dither)
{
    unsigned int scalebits;
    mad_fixed_t output, mask, random;

    enum {
        MIN = -MAD_F_ONE,
        MAX =  MAD_F_ONE - 1
    };

    assert (dither->magic == DITHER_MAGIC);

    /* noise shape */
    sample += dither->error[0] - dither->error[1] + dither->error[2];

    dither->error[2] = dither->error[1];
    dither->error[1] = dither->error[0] / 2;

    /* bias */
    output = sample + (1L << (MAD_F_FRACBITS + 1 - bits - 1));

    scalebits = MAD_F_FRACBITS + 1 - bits;
    mask = (1L << scalebits) - 1;

    /* dither */
    random  = prng (dither->random);
    output += (random & mask) - (dither->random & mask);

    dither->random = random;

    /* clip */
    if (output > MAX) {
        output = MAX;

        if (sample > MAX)
            sample = MAX;
    }
    else if (output < MIN) {
        output = MIN;

        if (sample < MIN)
            sample = MIN;
    }

    /* quantize */
    output &= ~mask;

    /* error feedback */
    dither->error[0] = sample - output;

    /* scale */
    return output >> scalebits;
}

static
__inline__
unsigned long prng (unsigned long state)
{
  return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
}

static
enum mad_flow output (audio_data_t _data,
                      struct mad_header const *header,
                      struct mad_pcm *pcm)
{
    struct_audio_data_t *data = _data;
    
    /* The buffer that we will tell libao to audio_play. 1152 is the max
     * buffer we will get from mad. Stereo and a 16bit samplesize
     * means that we'll  have to multiply it by 4 (2 channels * 2 bytes).
     */
    static unsigned char stream[1152 * 4];
    
    /* A pointer within the stream-buffer. It uses register keyword because
     * we'll probably use it alot */
    register unsigned char *ptr = stream;

    /* This contains our current sample. This is what we let libao
     * play */
    register signed int sample;
    
    /* This contains our temporary sample.
     * We will run audio_linear_dither and normalize this */
    register mad_fixed_t tempsample;
    
/*    static struct audio_dither dither;*/
    
    unsigned int nchannels, nsamples, samplerate;
    mad_fixed_t const *left_ch, *right_ch;


    /* resetting the dither struct */
    pthread_mutex_lock(&data->mutex);
    reset_dither(data->mp3_dither);

    nchannels = pcm->channels;
    nsamples  = pcm->length;
    left_ch   = pcm->samples[0];
    right_ch  = pcm->samples[1];

    samplerate = pcm->samplerate;

    /* We need to know information about the file before we can open the
     * playdevice in some cases. So, we do it here. */
    if (!data->device)  /* if ao haven't opened a playdevice yet */
    {
        if (DEBUG_MP3) report ("First time we play - initializing daisylibao", REP_DEBUG);
        data->device = libao_initiate((int) AO_FMT_LITTLE, (int) pcm->channels, (int) pcm->samplerate);
        assert (data->device != NULL);
    }
    /* if channels or samplerate changes. (this should never happen in
     * daisy-books) */
    else if ((nchannels != MAD_NCHANNELS(header) || samplerate != header->samplerate))
    {
        if (DEBUG_MP3) report ("channels or samplerate have changed!", REP_DEBUG);
        libao_terminate(data->device);
        data->device = libao_initiate(AO_FMT_LITTLE, pcm->channels, pcm->samplerate);
        assert (data->device != NULL);
    }
    
    pthread_mutex_unlock(&data->mutex);
    
    /*
     * Stereo.
     * Output sample(s) in 16-bit signed little-endian PCM.
     */
    if (pcm->channels == 2)
    {
        while (nsamples--) {
            tempsample = *left_ch++;
            sample = (signed int) audio_linear_dither(16, tempsample, data->mp3_dither);
            
            *ptr++ = (unsigned char) (sample >> 0); /* Assumes that words ar big-endian. If they're not, we'll need to switch the two following lines. */
            *ptr++ = (unsigned char) (sample >> 8);
            
            tempsample = *right_ch++;
            sample = (signed int) audio_linear_dither(16, tempsample, data->mp3_dither);
            
            *ptr++ = (unsigned char) (sample >> 0); /* Assumes that words ar big-endian. If they're not, we'll need to switch the two following lines. */
            *ptr++ = (unsigned char) (sample >> 8);
        }
        libao_play (data->device, stream, pcm->length * 4);
    }

    /*
     * Mono.
     * Output sample(s) in 16-bit signed little-endian PCM
     */
    else
    {
        while (nsamples--)
        {
            tempsample = *left_ch++;
            sample = (signed int) audio_linear_dither(16, tempsample, data->mp3_dither);
            
            *ptr++ = (unsigned char) (sample >> 0); /* Assumes that words ar big-endian. If they're not, we'll need to switch the two following lines. */
            *ptr++ = (unsigned char) (sample >> 8);
        }
        libao_play (data->device, stream, pcm->length * 2);
    }
    return MAD_FLOW_CONTINUE;   /* Continue decoding */
}

static
enum mad_flow error (audio_data_t _data,
                     struct mad_stream *stream,
                     struct mad_frame *frame)
{
    
    struct_audio_data_t *data = _data;

    frame = NULL;   /* we don't use this */

    if (DEBUG_MP3)  /* If debug is enabled, we report error messages. */
    {
        char error[STRLEN]; /* prepare an error-message */
        snprintf (error, sizeof (error), "decoding error 0x%04x (%s) at byte offset %u",
                 stream->error, mad_stream_errorstr(stream),
                 stream->this_frame - data->buffer.buffer_start);
        report (error, REP_DEBUG);  /* report the error-message */
    }

    /* return MAD_FLOW_BREAK here to stop decoding (and propagate an error) */

    return MAD_FLOW_CONTINUE;
}

static
enum mad_flow header (audio_data_t data, struct mad_header const *header)
{
    struct_audio_data_t *_data = data;
    long int progress_ms = 0;

    pthread_mutex_lock (&_data->mutex);
    /*if (DEBUG_THREADS) printf ("mp3_header got mutex\n");*/

    /* we increment our duration */
    _data->progress.fraction += header->duration.fraction;
    _data->progress.seconds  += header->duration.seconds;
    if (_data->progress.fraction > MAD_TIMER_RESOLUTION)
    {
        _data->progress.seconds  += _data->progress.fraction / MAD_TIMER_RESOLUTION;
        _data->progress.fraction %= MAD_TIMER_RESOLUTION;
    }

    /* compares progress agains start- and stop-points */
    if (_data->start.seconds > _data->progress.seconds) {
        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        /*if (DEBUG_THREADS) printf ("mp3_header released mutex\n");*/
        return MAD_FLOW_IGNORE;
    }

    if (_data->start.seconds == _data->progress.seconds && _data->start.fraction > _data->progress.fraction) {
        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        /*if (DEBUG_THREADS) printf ("mp3_header released mutex\n");*/
        return MAD_FLOW_IGNORE;
    }

    if ((_data->stop.seconds <= _data->progress.seconds) &&
        (_data->stop.fraction <= _data->progress.fraction))
    {
        if (DEBUG_MP3) report ("mp3.c Finished playing segment. return MAD_FLOW_STOP", REP_DEBUG);
        pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
        /*if (DEBUG_THREADS) printf ("mp3_header released mutex\n");*/
        return MAD_FLOW_STOP;
    }

    progress_ms = mad_timer_count(_data->progress, MAD_UNITS_MILLISECONDS); /* store our proress */

    pthread_mutex_unlock (&_data->mutex);   /* release mutex - we're done with "data" */
    /*if (DEBUG_THREADS) printf ("mp3_header released mutex before callback\n");*/
    if (callback (_data, progress_ms) == -1) {  /* STOP */
        /*if (DEBUG_MP3) report ("mp3.c: callback returned -1. stopping decoder", REP_DEBUG);*/
        return MAD_FLOW_STOP;
    }

    return MAD_FLOW_CONTINUE;
}

static
struct audio_dither * init_dither (void)
{
    struct audio_dither *dither = NULL;
    if ((dither = (struct audio_dither *) malloc (sizeof (struct audio_dither))) == NULL)
    {
        report("init_dither could not allocate memory", REP_CRITICAL);
    }
    dither->magic = DITHER_MAGIC;
    reset_dither (dither);
    return dither;
}

static
void reset_dither (struct audio_dither *dither)
{
    assert (dither->magic == DITHER_MAGIC);
    dither->error[0] = 0;
    dither->error[1] = 0;
    dither->error[2] = 0;
    dither->random = 0;
}

static
void free_dither (struct audio_dither *dither)
{
    if(dither->magic == DITHER_MAGIC)
    {
        dither->magic = 0x00000000;
        free (dither);
    }
}


static
int mp3_decode (struct_audio_data_t *data)
{
    struct mad_decoder decoder;
    int result;

    /* initialize the buffer-part of the audio_data struct */
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("mp3_decode has mutex\n");
    
    data->mp3_dither = init_dither ();  /* create a dither struct */    
    data->buffer.buffer_start = data->fdm;
    data->buffer.buffer_length = data->stat.st_size;
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */

    if (DEBUG_THREADS) printf ("mp3_decode released mutex\n");
    
    /* configure input, output, and error functions */
    mad_decoder_init (&decoder, /* mad decoder      */
                      data,     /* data structure   */
                      input,    /* input function   */
                      header,   /* header function  */
                      0,        /* filter function  */
                      output,   /* output function  */
                      error,    /* error function   */
                      0         /* message function */);

    result = mad_decoder_run (&decoder, MAD_DECODER_MODE_SYNC); /* start decoding */

    mad_decoder_finish (&decoder);  /* release the decoder */

    pthread_mutex_lock (&data->mutex);
    free_dither(data->mp3_dither);  /* free dither struct */
    pthread_mutex_unlock (&data->mutex);
    
    return result;
}



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

void mp3_init (struct_audio_data_t *data)
{
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("mp3_init has mutex\n");

    /* Initializing the mp3 data struct */
    if (data == NULL) {
        data->cb_error (data->daisy, DAISY_ERROR_AUDIO_DATA_IS_NULL, NULL);
        report ("data pointer is NULL.", REP_CRITICAL);
    }
    if (DEBUG_MP3) report("initializing audio_data", REP_DEBUG);
    data->progress.fraction = 0;
    data->progress.seconds  = 0;
    
    /* output device should be NULL if it's not initialized already */
    data->device = NULL;
    
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with "data" */
    if (DEBUG_THREADS) printf ("mp3_init released mutex\n");
}

bool mp3_play (struct_audio_data_t *data)
{
    pthread_mutex_lock (&data->mutex);
    if (DEBUG_THREADS) printf ("mp3_play has mutex\n");
    data->progress.seconds = 0; /* initialize some data in the audio_data struct */
    data->progress.fraction = 0;
    pthread_mutex_unlock (&data->mutex);    /* release mutex - we're done with data */
    if (DEBUG_THREADS) printf ("mp3_play released mutex\n");

    if (DEBUG_MP3)
    {
        char msg[STRLEN];
        snprintf (msg, sizeof (msg), "mp3_play: Starting mp3 decoding.\nFile: %s\tMemory pos: %p", data->file_name, data->fdm);
        report(msg, REP_DEBUG);
    }

    mp3_decode (data);  /* start decoding the data */
    return false;
}

void mp3_close (struct_audio_data_t *data)
{
    libao_terminate (data->device); /* freeing daisyLibao */
}

---