apps/codecs/demac/demac.c

   1 /*
   2
   3 demac - A Monkey's Audio decoder
   4
   5 $Id$
   6
   7 Copyright (C) Dave Chapman 2007
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
  22
  23 */
  24
  25 /*
  26
  27 This example is intended to demonstrate how the decoder can be used in
  28 embedded devices - there is no usage of dynamic memory (i.e. no
  29 malloc/free) and small buffer sizes are chosen to minimise both the
  30 memory usage and decoding latency.
  31
  32 This implementation requires the following memory and supports decoding of all APE files up to 24-bit Stereo.
  33
  34 32768 - data from the input stream to be presented to the decoder in one contiguous chunk.
  35 18432 - decoding buffer (left channel)
  36 18432 - decoding buffer (right channel)
  37
  38 17408+5120+2240 - buffers used for filter histories (compression levels 2000-5000)
  39
  40 In addition, this example uses a static 27648 byte buffer as temporary
  41 storage for outputting the data to a WAV file but that could be
  42 avoided by writing the decoded data one sample at a time.
  43
  44 */
  45
  46 #include <stdio.h>
  47 #include <inttypes.h>
  48 #include <stdlib.h>
  49 #include <sys/types.h>
  50 #include <sys/stat.h>
  51 #include <fcntl.h>
  52 #include <unistd.h>
  53 #include <string.h>
  54
  55 #include "demac.h"
  56 #include "wavwrite.h"
  57
  58 #ifndef __WIN32__
  59 #define O_BINARY 0
  60 #endif
  61
  62 #define CALC_CRC 1
  63
  64 #define BLOCKS_PER_LOOP     4608
  65 #define MAX_CHANNELS        2
  66 #define MAX_BYTESPERSAMPLE  3
  67
  68 #define INPUT_CHUNKSIZE     (32*1024)
  69
  70 #ifndef MIN
  71 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  72 #endif
  73
  74
  75 /* 4608*2*3 = 27648 bytes */
  76 static unsigned char wavbuffer[BLOCKS_PER_LOOP*MAX_CHANNELS*MAX_BYTESPERSAMPLE];
  77
  78 /* 4608*4 = 18432 bytes per channel */
  79 static int32_t decoded0[BLOCKS_PER_LOOP];
  80 static int32_t decoded1[BLOCKS_PER_LOOP];
  81
  82 /* We assume that 32KB of compressed data is enough to extract up to
  83    27648 bytes of decompressed data. */
  84
  85 static unsigned char inbuffer[INPUT_CHUNKSIZE];
  86
  87 int ape_decode(char* infile, char* outfile)
  88 {
  89     int fd;
  90     int fdwav;
  91     int currentframe;
  92     int nblocks;
  93     int bytesconsumed;
  94     struct ape_ctx_t ape_ctx;
  95     int i, n;
  96     unsigned char* p;
  97     int bytesinbuffer;
  98     int blockstodecode;
  99     int res;
 100     int firstbyte;
 101     int16_t  sample16;
 102     int32_t  sample32;
 103     uint32_t frame_crc;
 104     int crc_errors = 0;
 105
 106     fd = open(infile,O_RDONLY|O_BINARY);
 107     if (fd < 0) return -1;
 108
 109     /* Read the file headers to populate the ape_ctx struct */
 110     if (ape_parseheader(fd,&ape_ctx) < 0) {
 111         printf("Cannot read header\n");
 112         close(fd);
 113         return -1;
 114     }
 115
 116     if ((ape_ctx.fileversion < APE_MIN_VERSION) || (ape_ctx.fileversion > APE_MAX_VERSION)) {
 117         printf("Unsupported file version - %.2f\n", ape_ctx.fileversion/1000.0);
 118         close(fd);
 119         return -2;
 120     }
 121
 122     //ape_dumpinfo(&ape_ctx);
 123
 124     printf("Decoding file - v%.2f, compression level %d\n",ape_ctx.fileversion/1000.0,ape_ctx.compressiontype);
 125
 126     /* Open the WAV file and write a canonical 44-byte WAV header
 127        based on the audio format information in the ape_ctx struct.
 128
 129        NOTE: This example doesn't write the original WAV header and
 130              tail data which are (optionally) stored in the APE file.
 131      */
 132     fdwav = open_wav(&ape_ctx,outfile);
 133
 134     currentframe = 0;
 135
 136     /* Initialise the buffer */
 137     lseek(fd, ape_ctx.firstframe, SEEK_SET);
 138     bytesinbuffer = read(fd, inbuffer, INPUT_CHUNKSIZE);
 139     firstbyte = 3;  /* Take account of the little-endian 32-bit byte ordering */
 140
 141     /* The main decoding loop - we decode the frames a small chunk at a time */
 142     while (currentframe < ape_ctx.totalframes)
 143     {
 144         /* Calculate how many blocks there are in this frame */
 145         if (currentframe == (ape_ctx.totalframes - 1))
 146             nblocks = ape_ctx.finalframeblocks;
 147         else
 148             nblocks = ape_ctx.blocksperframe;
 149
 150         ape_ctx.currentframeblocks = nblocks;
 151
 152         /* Initialise the frame decoder */
 153         init_frame_decoder(&ape_ctx, inbuffer, &firstbyte, &bytesconsumed);
 154
 155         /* Update buffer */
 156         memmove(inbuffer,inbuffer + bytesconsumed, bytesinbuffer - bytesconsumed);
 157         bytesinbuffer -= bytesconsumed;
 158
 159         n = read(fd, inbuffer + bytesinbuffer, INPUT_CHUNKSIZE - bytesinbuffer);
 160         bytesinbuffer += n;
 161
 162 #if CALC_CRC
 163         frame_crc = ape_initcrc();
 164 #endif
 165
 166         /* Decode the frame a chunk at a time */
 167         while (nblocks > 0)
 168         {
 169             blockstodecode = MIN(BLOCKS_PER_LOOP, nblocks);
 170
 171             if ((res = decode_chunk(&ape_ctx, inbuffer, &firstbyte,
 172                                     &bytesconsumed,
 173                                     decoded0, decoded1,
 174                                     blockstodecode)) < 0)
 175             {
 176                 /* Frame decoding error, abort */
 177                 close(fd);
 178                 return res;
 179             }
 180
 181             /* Convert the output samples to WAV format and write to output file */
 182             p = wavbuffer;
 183             if (ape_ctx.bps == 8) {
 184                 for (i = 0 ; i < blockstodecode ; i++)
 185                 {
 186                     /* 8 bit WAV uses unsigned samples */
 187                     *(p++) = (decoded0[i] + 0x80) & 0xff;
 188
 189                     if (ape_ctx.channels == 2) {
 190                         *(p++) = (decoded1[i] + 0x80) & 0xff;
 191                     }
 192                 }
 193             } else if (ape_ctx.bps == 16) {
 194                 for (i = 0 ; i < blockstodecode ; i++)
 195                 {
 196                     sample16 = decoded0[i];
 197                     *(p++) = sample16 & 0xff;
 198                     *(p++) = (sample16 >> 8) & 0xff;
 199
 200                     if (ape_ctx.channels == 2) {
 201                         sample16 = decoded1[i];
 202                         *(p++) = sample16 & 0xff;
 203                         *(p++) = (sample16 >> 8) & 0xff;
 204                     }
 205                 }
 206             } else if (ape_ctx.bps == 24) {
 207                 for (i = 0 ; i < blockstodecode ; i++)
 208                 {
 209                     sample32 = decoded0[i];
 210                     *(p++) = sample32 & 0xff;
 211                     *(p++) = (sample32 >> 8) & 0xff;
 212                     *(p++) = (sample32 >> 16) & 0xff;
 213
 214                     if (ape_ctx.channels == 2) {
 215                         sample32 = decoded1[i];
 216                         *(p++) = sample32 & 0xff;
 217                         *(p++) = (sample32 >> 8) & 0xff;
 218                         *(p++) = (sample32 >> 16) & 0xff;
 219                     }
 220                 }
 221             }
 222
 223 #if CALC_CRC
 224             frame_crc = ape_updatecrc(wavbuffer, p - wavbuffer, frame_crc);
 225 #endif
 226             write(fdwav,wavbuffer,p - wavbuffer);
 227
 228             /* Update the buffer */
 229             memmove(inbuffer,inbuffer + bytesconsumed, bytesinbuffer - bytesconsumed);
 230             bytesinbuffer -= bytesconsumed;
 231
 232             n = read(fd, inbuffer + bytesinbuffer, INPUT_CHUNKSIZE - bytesinbuffer);
 233             bytesinbuffer += n;
 234
 235             /* Decrement the block count */
 236             nblocks -= blockstodecode;
 237         }
 238
 239 #if CALC_CRC
 240         frame_crc = ape_finishcrc(frame_crc);
 241
 242         if (ape_ctx.CRC != frame_crc)
 243         {
 244             fprintf(stderr,"CRC error in frame %d\n",currentframe);
 245             crc_errors++;
 246         }
 247 #endif
 248
 249         currentframe++;
 250     }
 251
 252     close(fd);
 253     close(fdwav);
 254
 255     if (crc_errors > 0)
 256         return -1;
 257     else
 258         return 0;
 259 }
 260
 261 int main(int argc, char* argv[])
 262 {
 263     int res;
 264
 265     if (argc != 3) {
 266         fprintf(stderr,"Usage: demac infile.ape outfile.wav\n");
 267         return 0;
 268     }
 269
 270     res = ape_decode(argv[1], argv[2]);
 271
 272     if (res < 0)
 273     {
 274         fprintf(stderr,"DECODING ERROR %d, ABORTING\n", res);
 275     }
 276     else
 277     {
 278         fprintf(stderr,"DECODED OK - NO CRC ERRORS.\n");
 279     }
 280
 281     return 0;
 282 }