apps/codecs/ape.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Dave Chapman
  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/demac/libdemac/demac.h>
  24
  25 CODEC_HEADER
  26
  27 #define BLOCKS_PER_LOOP     1024
  28 #define MAX_CHANNELS        2
  29 #define MAX_BYTESPERSAMPLE  3
  30
  31 /* Monkey's Audio files have one seekpoint per frame.  The framesize
  32    varies between 73728 and 1179648 samples.
  33
  34    At the smallest framesize, 30000 frames would be 50155 seconds of
  35    audio - almost 14 hours.  This should be enough for any file a user
  36    would want to play in Rockbox, given the 2GB FAT filesize (and 4GB
  37    seektable entry size) limit.
  38
  39    This means the seektable is 120000 bytes, but we have a lot of
  40    spare room in the codec buffer - the APE codec itself is small.
  41 */
  42
  43 #define MAX_SEEKPOINTS      30000
  44 static uint32_t seektablebuf[MAX_SEEKPOINTS];
  45
  46 #define INPUT_CHUNKSIZE     (32*1024)
  47
  48 /* 4608*4 = 18432 bytes per channel */
  49 static int32_t decoded0[BLOCKS_PER_LOOP] IBSS_ATTR;
  50 static int32_t decoded1[BLOCKS_PER_LOOP] IBSS_ATTR;
  51
  52 #define MAX_SUPPORTED_SEEKTABLE_SIZE 5000
  53
  54
  55 /* Given an ape_ctx and a sample to seek to, return the file position
  56    to the frame containing that sample, and the number of samples to
  57    skip in that frame.
  58 */
  59
  60 bool ape_calc_seekpos(struct ape_ctx_t* ape_ctx,
  61                       uint32_t new_sample,
  62                       uint32_t* newframe,
  63                       uint32_t* filepos,
  64                       uint32_t* samplestoskip)
  65 {
  66     uint32_t n;
  67
  68     n = new_sample / ape_ctx->blocksperframe;
  69     if (n >= ape_ctx->numseekpoints)
  70     {
  71         /* We don't have a seekpoint for that frame */
  72         return false;
  73     }
  74
  75     *newframe = n;
  76     *filepos = ape_ctx->seektable[n];
  77     *samplestoskip = new_sample - (n * ape_ctx->blocksperframe);
  78
  79     return true;
  80 }
  81
  82 /* The resume offset is a value in bytes - we need to
  83    turn it into a frame number and samplestoskip value */
  84
  85 void ape_resume(struct ape_ctx_t* ape_ctx, size_t resume_offset,
  86                 uint32_t* currentframe, uint32_t* samplesdone,
  87                 uint32_t* samplestoskip, int* firstbyte)
  88 {
  89     off_t newfilepos;
  90     int64_t framesize;
  91     int64_t offset;
  92
  93     *currentframe = 0;
  94     *samplesdone = 0;
  95     *samplestoskip = 0;
  96
  97     while ((*currentframe < ape_ctx->totalframes) &&
  98            (*currentframe < ape_ctx->numseekpoints) &&
  99            (resume_offset > ape_ctx->seektable[*currentframe]))
 100     {
 101         ++*currentframe;
 102         *samplesdone += ape_ctx->blocksperframe;
 103     }
 104
 105     if ((*currentframe > 0) &&
 106         (ape_ctx->seektable[*currentframe] > resume_offset)) {
 107         --*currentframe;
 108         *samplesdone -= ape_ctx->blocksperframe;
 109     }
 110
 111     newfilepos = ape_ctx->seektable[*currentframe];
 112
 113     /* APE's bytestream is weird... */
 114     *firstbyte = 3 - (newfilepos & 3);
 115     newfilepos &= ~3;
 116
 117     ci->seek_buffer(newfilepos);
 118
 119     /* We estimate where we were in the current frame, based on the
 120        byte offset */
 121     if (*currentframe < (ape_ctx->totalframes - 1)) {
 122         framesize = ape_ctx->seektable[*currentframe+1] - ape_ctx->seektable[*currentframe];
 123         offset = resume_offset - ape_ctx->seektable[*currentframe];
 124
 125         *samplestoskip = (offset * ape_ctx->blocksperframe) / framesize;
 126     }
 127 }
 128
 129 /* this is the codec entry point */
 130 enum codec_status codec_main(void)
 131 {
 132     struct ape_ctx_t ape_ctx;
 133     uint32_t samplesdone;
 134     uint32_t elapsedtime;
 135     size_t bytesleft;
 136     int retval;
 137
 138     uint32_t currentframe;
 139     uint32_t newfilepos;
 140     uint32_t samplestoskip;
 141     int nblocks;
 142     int bytesconsumed;
 143     unsigned char* inbuffer;
 144     uint32_t blockstodecode;
 145     int res;
 146     int firstbyte;
 147     size_t resume_offset;
 148
 149     /* Generic codec initialisation */
 150     ci->configure(CODEC_SET_FILEBUF_WATERMARK, 1024*512);
 151
 152     ci->configure(DSP_SET_SAMPLE_DEPTH, APE_OUTPUT_DEPTH-1);
 153
 154     next_track:
 155
 156     retval = CODEC_OK;
 157
 158     /* Remember the resume position - when the codec is opened, the
 159        playback engine will reset it. */
 160     resume_offset = ci->id3->offset;
 161
 162     if (codec_init()) {
 163         LOGF("APE: Error initialising codec\n");
 164         retval = CODEC_ERROR;
 165         goto exit;
 166     }
 167
 168     while (!*ci->taginfo_ready && !ci->stop_codec)
 169         ci->sleep(1);
 170
 171     inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
 172
 173     /* Read the file headers to populate the ape_ctx struct */
 174     if (ape_parseheaderbuf(inbuffer,&ape_ctx) < 0) {
 175         LOGF("APE: Error reading header\n");
 176         retval = CODEC_ERROR;
 177         goto exit;
 178     }
 179
 180     /* Initialise the seektable for this file */
 181     ape_ctx.seektable = seektablebuf;
 182     ape_ctx.numseekpoints = MIN(MAX_SEEKPOINTS,ape_ctx.numseekpoints);
 183
 184     ci->advance_buffer(ape_ctx.seektablefilepos);
 185
 186     /* The seektable may be bigger than the guard buffer (32KB), so we
 187        do a read() */
 188     ci->read_filebuf(ape_ctx.seektable, ape_ctx.numseekpoints * sizeof(uint32_t));
 189
 190 #ifdef ROCKBOX_BIG_ENDIAN
 191     /* Byte-swap the little-endian seekpoints */
 192     {
 193         uint32_t i;
 194
 195         for(i = 0; i < ape_ctx.numseekpoints; i++)
 196             ape_ctx.seektable[i] = swap32(ape_ctx.seektable[i]);
 197     }
 198 #endif
 199
 200     /* Now advance the file position to the first frame */
 201     ci->advance_buffer(ape_ctx.firstframe -
 202                        (ape_ctx.seektablefilepos +
 203                         ape_ctx.numseekpoints * sizeof(uint32_t)));
 204
 205     ci->configure(DSP_SWITCH_FREQUENCY, ape_ctx.samplerate);
 206     ci->configure(DSP_SET_STEREO_MODE, ape_ctx.channels == 1 ?
 207                   STEREO_MONO : STEREO_NONINTERLEAVED);
 208     codec_set_replaygain(ci->id3);
 209
 210     /* The main decoding loop */
 211
 212     if (resume_offset) {
 213         /* The resume offset is a value in bytes - we need to
 214            turn it into a frame number and samplestoskip value */
 215
 216         ape_resume(&ape_ctx, resume_offset,
 217                    &currentframe, &samplesdone, &samplestoskip, &firstbyte);
 218     } else {
 219         currentframe = 0;
 220         samplesdone = 0;
 221         samplestoskip = 0;
 222         firstbyte = 3;  /* Take account of the little-endian 32-bit byte ordering */
 223     }
 224
 225     /* Initialise the buffer */
 226     inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
 227
 228     /* The main decoding loop - we decode the frames a small chunk at a time */
 229     while (currentframe < ape_ctx.totalframes)
 230     {
 231 frame_start:
 232         /* Calculate how many blocks there are in this frame */
 233         if (currentframe == (ape_ctx.totalframes - 1))
 234             nblocks = ape_ctx.finalframeblocks;
 235         else
 236             nblocks = ape_ctx.blocksperframe;
 237
 238         ape_ctx.currentframeblocks = nblocks;
 239
 240         /* Initialise the frame decoder */
 241         init_frame_decoder(&ape_ctx, inbuffer, &firstbyte, &bytesconsumed);
 242
 243         ci->advance_buffer(bytesconsumed);
 244         inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
 245
 246         /* Decode the frame a chunk at a time */
 247         while (nblocks > 0)
 248         {
 249             ci->yield();
 250             if (ci->stop_codec || ci->new_track) {
 251                 goto done;
 252             }
 253
 254             /* Deal with any pending seek requests */
 255             if (ci->seek_time)
 256             {
 257                 if (ape_calc_seekpos(&ape_ctx,
 258                     ((ci->seek_time-1)/10) * (ci->id3->frequency/100),
 259                     &currentframe,
 260                     &newfilepos,
 261                     &samplestoskip))
 262                 {
 263                     samplesdone = currentframe * ape_ctx.blocksperframe;
 264
 265                     /* APE's bytestream is weird... */
 266                     firstbyte = 3 - (newfilepos & 3);
 267                     newfilepos &= ~3;
 268
 269                     ci->seek_buffer(newfilepos);
 270                     inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
 271
 272                     ci->seek_complete();
 273                     goto frame_start;  /* Sorry... */
 274                 }
 275                 ci->seek_complete();
 276             }
 277
 278             blockstodecode = MIN(BLOCKS_PER_LOOP, nblocks);
 279
 280             if ((res = decode_chunk(&ape_ctx, inbuffer, &firstbyte,
 281                                     &bytesconsumed,
 282                                     decoded0, decoded1,
 283                                     blockstodecode)) < 0)
 284             {
 285                 /* Frame decoding error, abort */
 286                 LOGF("APE: Frame %d, error %d\n",currentframe,res);
 287                 retval = CODEC_ERROR;
 288                 goto done;
 289             }
 290
 291             ci->yield();
 292
 293             if (samplestoskip > 0) {
 294                 if (samplestoskip < blockstodecode) {
 295                     ci->pcmbuf_insert(decoded0 + samplestoskip,
 296                                       decoded1 + samplestoskip,
 297                                       blockstodecode - samplestoskip);
 298                     samplestoskip = 0;
 299                 } else {
 300                     samplestoskip -= blockstodecode;
 301                 }
 302             } else {
 303                 ci->pcmbuf_insert(decoded0, decoded1, blockstodecode);
 304             }
 305
 306             samplesdone += blockstodecode;
 307
 308             if (!samplestoskip) {
 309                 /* Update the elapsed-time indicator */
 310                 elapsedtime = (samplesdone*10)/(ape_ctx.samplerate/100);
 311                 ci->set_elapsed(elapsedtime);
 312             }
 313
 314             ci->advance_buffer(bytesconsumed);
 315             inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
 316
 317             /* Decrement the block count */
 318             nblocks -= blockstodecode;
 319         }
 320
 321         currentframe++;
 322     }
 323
 324     retval = CODEC_OK;
 325
 326 done:
 327     LOGF("APE: Decoded %ld samples\n",samplesdone);
 328
 329     if (ci->request_next_track())
 330         goto next_track;
 331
 332 exit:
 333     return retval;
 334 }