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 = CODEC_OK;
  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     if (codec_init())
  83     {
  84         retval = CODEC_ERROR;
  85         goto exit;
  86     }
  87
  88     while (!*ci->taginfo_ready && !ci->stop_codec)
  89         ci->sleep(1);
  90
  91     /* Initialize demux/decoder. */
  92     demux = mpc_demux_init(&reader);
  93     if (NULL == demux)
  94     {
  95         retval = CODEC_ERROR;
  96         goto done;
  97     }
  98     /* Read file's streaminfo data. */
  99     mpc_demux_get_info(demux, &info);
 100
 101     byterate  = (mpc_uint32_t)(info.average_bitrate) / 8;
 102     frequency = info.sample_freq / 100; /* 0.1 kHz accuracy */
 103     ci->configure(DSP_SWITCH_FREQUENCY, info.sample_freq);
 104
 105     /* Remark: rockbox offset is the file offset in bytes. So, estimate the
 106      * sample seek position from the file offset, the sampling frequency and
 107      * the bitrate. As the saved position is exactly calculated the reverse way
 108      * there is no loss of information except rounding. */
 109     samplesdone = 100 * ((mpc_uint64_t)(ci->id3->offset * frequency) / byterate);
 110
 111     /* Set up digital signal processing for correct number of channels */
 112     /* NOTE: current musepack format only allows for stereo files
 113        but code is here to handle other configurations anyway */
 114     if      (info.channels == 2)
 115         ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
 116     else if (info.channels == 1)
 117         ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 118     else
 119     {
 120        retval = CODEC_ERROR;
 121        goto done;
 122     }
 123
 124     codec_set_replaygain(ci->id3);
 125
 126     /* Resume to saved sample offset. */
 127     if (samplesdone > 0)
 128     {
 129         if (mpc_demux_seek_sample(demux, samplesdone) == MPC_STATUS_OK)
 130         {
 131             elapsed_time = (samplesdone*10)/frequency;
 132             ci->set_elapsed(elapsed_time);
 133         }
 134         else
 135         {
 136             samplesdone = 0;
 137         }
 138     }
 139
 140     /* This is the decoding loop. */
 141     do
 142     {
 143         /* Complete seek handler. */
 144         if (ci->seek_time)
 145         {
 146             mpc_int64_t new_offset = ((ci->seek_time - 1)/10)*frequency;
 147             if (mpc_demux_seek_sample(demux, new_offset) == MPC_STATUS_OK)
 148             {
 149                 samplesdone = new_offset;
 150                 ci->set_elapsed(ci->seek_time);
 151             }
 152             ci->seek_complete();
 153         }
 154
 155         /* Stop or skip occured, exit decoding loop. */
 156         if (ci->stop_codec || ci->new_track)
 157             break;
 158
 159         /* Decode one frame. */
 160         status = mpc_demux_decode(demux, &frame);
 161         ci->yield();
 162         if (frame.bits == -1)
 163         {
 164             /* Decoding error, exit decoding loop. */
 165             retval = (status == MPC_STATUS_OK) ? CODEC_OK : CODEC_ERROR;
 166             goto done;
 167         }
 168         else
 169         {
 170             /* Decoding passed, insert samples to PCM buffer. */
 171             ci->pcmbuf_insert(frame.buffer,
 172                               frame.buffer + MPC_FRAME_LENGTH,
 173                               frame.samples);
 174             samplesdone += frame.samples;
 175             elapsed_time = (samplesdone*10)/frequency;
 176             ci->set_elapsed(elapsed_time);
 177             /* Remark: rockbox offset is the file offset in bytes. So estimate
 178              * this offset from the samples, sampling frequency and bitrate */
 179             ci->set_offset( (samplesdone * byterate)/(frequency*100) );
 180         }
 181     } while (true);
 182
 183 done:
 184     if (ci->request_next_track())
 185         goto next_track;
 186
 187 exit:
 188     return retval;
 189 }