apps/codecs/mpc.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Thom Johansen
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "codeclib.h"
  23 #include <codecs/libmusepack/mpcdec.h>
  24 #include <codecs/libmusepack/internal.h>
  25
  26 CODEC_HEADER
  27
  28 static MPC_SAMPLE_FORMAT sample_buffer[MPC_DECODER_BUFFER_LENGTH] IBSS_ATTR;
  29
  30 /* Our implementations of the mpc_reader callback functions. */
  31 static mpc_int32_t read_impl(mpc_reader *reader, void *ptr, mpc_int32_t size)
  32 {
  33     (void)reader;
  34     return ((mpc_int32_t)(ci->read_filebuf(ptr, size)));
  35 }
  36
  37 static mpc_bool_t seek_impl(mpc_reader *reader, mpc_int32_t offset)
  38 {
  39     (void)reader;
  40     return ci->seek_buffer(offset);
  41 }
  42
  43 static mpc_int32_t tell_impl(mpc_reader *reader)
  44 {
  45     (void)reader;
  46     return ci->curpos;
  47 }
  48
  49 static mpc_int32_t get_size_impl(mpc_reader *reader)
  50 {
  51     (void)reader;
  52     return ci->filesize;
  53 }
  54
  55 /* This is the codec entry point. */
  56 enum codec_status codec_main(void)
  57 {
  58     mpc_int64_t samplesdone;
  59     uint32_t frequency;     /* 0.1 kHz accuracy */
  60     uint32_t elapsed_time;  /* milliseconds */
  61     uint32_t byterate;      /* bytes per second */
  62     mpc_status status;
  63     mpc_reader reader;
  64     mpc_streaminfo info;
  65     mpc_frame_info frame;
  66     mpc_demux *demux = NULL;
  67     int retval;
  68
  69     frame.buffer = sample_buffer;
  70
  71     /* musepack's sample representation is 18.14
  72      * DSP_SET_SAMPLE_DEPTH = 14 (FRACT) + 16 (NATIVE) - 1 (SIGN) = 29 */
  73     ci->configure(DSP_SET_SAMPLE_DEPTH, 29);
  74
  75     /* Create a decoder instance */
  76     reader.read     = read_impl;
  77     reader.seek     = seek_impl;
  78     reader.tell     = tell_impl;
  79     reader.get_size = get_size_impl;
  80
  81 next_track:
  82     retval = CODEC_OK;
  83
  84     if (codec_init())
  85     {
  86         retval = CODEC_ERROR;
  87         goto exit;
  88     }
  89
  90     if (codec_wait_taginfo() != 0)
  91         goto done;
  92
  93     /* Initialize demux/decoder. */
  94     demux = mpc_demux_init(&reader);
  95     if (NULL == demux)
  96     {
  97         retval = CODEC_ERROR;
  98         goto done;
  99     }
 100     /* Read file's streaminfo data. */
 101     mpc_demux_get_info(demux, &info);
 102
 103     byterate  = (mpc_uint32_t)(info.average_bitrate) / 8;
 104     frequency = info.sample_freq / 100; /* 0.1 kHz accuracy */
 105     ci->configure(DSP_SWITCH_FREQUENCY, info.sample_freq);
 106
 107     /* Remark: rockbox offset is the file offset in bytes. So, estimate the
 108      * sample seek position from the file offset, the sampling frequency and
 109      * the bitrate. As the saved position is exactly calculated the reverse way
 110      * there is no loss of information except rounding. */
 111     samplesdone = 100 * ((mpc_uint64_t)(ci->id3->offset * frequency) / byterate);
 112
 113     /* Set up digital signal processing for correct number of channels */
 114     /* NOTE: current musepack format only allows for stereo files
 115        but code is here to handle other configurations anyway */
 116     if      (info.channels == 2)
 117         ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
 118     else if (info.channels == 1)
 119         ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 120     else
 121     {
 122        retval = CODEC_ERROR;
 123        goto done;
 124     }
 125
 126     codec_set_replaygain(ci->id3);
 127
 128     /* Resume to saved sample offset. */
 129     if (samplesdone > 0)
 130     {
 131         if (mpc_demux_seek_sample(demux, samplesdone) == MPC_STATUS_OK)
 132         {
 133             elapsed_time = (samplesdone*10)/frequency;
 134             ci->set_elapsed(elapsed_time);
 135         }
 136         else
 137         {
 138             samplesdone = 0;
 139         }
 140     }
 141
 142     /* This is the decoding loop. */
 143     do
 144     {
 145         /* Complete seek handler. */
 146         if (ci->seek_time)
 147         {
 148             mpc_int64_t new_offset = ((ci->seek_time - 1)/10)*frequency;
 149             if (mpc_demux_seek_sample(demux, new_offset) == MPC_STATUS_OK)
 150             {
 151                 samplesdone = new_offset;
 152                 ci->set_elapsed(ci->seek_time);
 153             }
 154             ci->seek_complete();
 155         }
 156
 157         /* Stop or skip occured, exit decoding loop. */
 158         if (ci->stop_codec || ci->new_track)
 159             break;
 160
 161         /* Decode one frame. */
 162         status = mpc_demux_decode(demux, &frame);
 163         ci->yield();
 164         if (frame.bits == -1)
 165         {
 166             /* Decoding error, exit decoding loop. */
 167             retval = (status == MPC_STATUS_OK) ? CODEC_OK : CODEC_ERROR;
 168             goto done;
 169         }
 170         else
 171         {
 172             /* Decoding passed, insert samples to PCM buffer. */
 173             ci->pcmbuf_insert(frame.buffer,
 174                               frame.buffer + MPC_FRAME_LENGTH,
 175                               frame.samples);
 176             samplesdone += frame.samples;
 177             elapsed_time = (samplesdone*10)/frequency;
 178             ci->set_elapsed(elapsed_time);
 179             /* Remark: rockbox offset is the file offset in bytes. So estimate
 180              * this offset from the samples, sampling frequency and bitrate */
 181             ci->set_offset( (samplesdone * byterate)/(frequency*100) );
 182         }
 183     } while (true);
 184
 185 done:
 186     if (ci->request_next_track())
 187         goto next_track;
 188
 189 exit:
 190     return retval;
 191 }