apps/codecs/adx.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  * Copyright (C) 2006-2008 Adam Gashlin (hcs)
  10  * Copyright (C) 2006 Jens Arnold
  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 <limits.h>
  23 #include "codeclib.h"
  24 #include "inttypes.h"
  25 #include "math.h"
  26 #include "lib/fixedpoint.h"
  27
  28 CODEC_HEADER
  29
  30 /* Maximum number of bytes to process in one iteration */
  31 #define WAV_CHUNK_SIZE (1024*2)
  32
  33 /* Number of times to loop looped tracks when repeat is disabled */
  34 #define LOOP_TIMES 2
  35
  36 /* Length of fade-out for looped tracks (milliseconds) */
  37 #define FADE_LENGTH 10000L
  38
  39 /* Default high pass filter cutoff frequency is 500 Hz.
  40  * Others can be set, but the default is nearly always used,
  41  * and there is no way to determine if another was used, anyway.
  42  */
  43 static const long cutoff = 500;
  44
  45 static int16_t samples[WAV_CHUNK_SIZE] IBSS_ATTR;
  46
  47 /* this is the codec entry point */
  48 enum codec_status codec_main(enum codec_entry_call_reason reason)
  49 {
  50     if (reason == CODEC_LOAD) {
  51         /* Generic codec initialisation */
  52         /* we only render 16 bits */
  53         ci->configure(DSP_SET_SAMPLE_DEPTH, 16);
  54     }
  55
  56     return CODEC_OK;
  57 }
  58
  59 /* this is called for each file to process */
  60 enum codec_status codec_run(void)
  61 {
  62     int channels;
  63     int sampleswritten, i;
  64     uint8_t *buf;
  65     int32_t ch1_1, ch1_2, ch2_1, ch2_2; /* ADPCM history */
  66     size_t n;
  67     int endofstream; /* end of stream flag */
  68     uint32_t avgbytespersec;
  69     int looping; /* looping flag */
  70     int loop_count; /* number of loops done so far */
  71     int fade_count; /*  countdown for fadeout */
  72     int fade_frames; /* length of fade in frames */
  73     off_t start_adr, end_adr; /* loop points */
  74     off_t chanstart, bufoff;
  75     /*long coef1=0x7298L,coef2=-0x3350L;*/
  76     long coef1, coef2;
  77     intptr_t param;
  78
  79     DEBUGF("ADX: next_track\n");
  80     if (codec_init()) {
  81         return CODEC_ERROR;
  82     }
  83     DEBUGF("ADX: after init\n");
  84
  85     /* init history */
  86     ch1_1=ch1_2=ch2_1=ch2_2=0;
  87
  88     codec_set_replaygain(ci->id3);
  89
  90     /* Get header */
  91     DEBUGF("ADX: request initial buffer\n");
  92     ci->seek_buffer(0);
  93     buf = ci->request_buffer(&n, 0x38);
  94     if (!buf || n < 0x38) {
  95         return CODEC_ERROR;
  96     }
  97     bufoff = 0;
  98     DEBUGF("ADX: read size = %lx\n",(unsigned long)n);
  99
 100     /* Get file header for starting offset, channel count */
 101
 102     chanstart = ((buf[2] << 8) | buf[3]) + 4;
 103     channels = buf[7];
 104
 105     /* useful for seeking and reporting current playback position */
 106     avgbytespersec = ci->id3->frequency * 18 * channels / 32;
 107     DEBUGF("avgbytespersec=%ld\n",(unsigned long)avgbytespersec);
 108
 109     /* calculate filter coefficients */
 110
 111     /**
 112      * A simple table of these coefficients would be nice, but
 113      * some very odd frequencies are used and if I'm going to
 114      * interpolate I might as well just go all the way and
 115      * calclate them precisely.
 116      * Speed is not an issue as this only needs to be done once per file.
 117      */
 118     {
 119         const int64_t big28 = 0x10000000LL;
 120         const int64_t big32 = 0x100000000LL;
 121         int64_t frequency = ci->id3->frequency;
 122         int64_t phasemultiple = cutoff*big32/frequency;
 123
 124         long z;
 125         int64_t a;
 126         const int64_t b = (M_SQRT2*big28)-big28;
 127         int64_t c;
 128         int64_t d;
 129
 130         fp_sincos((unsigned long)phasemultiple,&z);
 131
 132         a = (M_SQRT2*big28)-(z*big28/LONG_MAX);
 133
 134         /**
 135          * In the long passed to fsqrt there are only 4 nonfractional bits,
 136          * which is sufficient here, but this is the only reason why I don't
 137          * use 32 fractional bits everywhere.
 138          */
 139         d = fp_sqrt((a+b)*(a-b)/big28,28);
 140         c = (a-d)*big28/b;
 141
 142         coef1 = (c*8192) >> 28;
 143         coef2 = (c*c/big28*-4096) >> 28;
 144         DEBUGF("ADX: samprate=%ld ",(long)frequency);
 145         DEBUGF("coef1 %04x ",(unsigned int)(coef1*4));
 146         DEBUGF("coef2 %04x\n",(unsigned int)(coef2*-4));
 147     }
 148
 149     /* Get loop data */
 150
 151     looping = 0; start_adr = 0; end_adr = 0;
 152     if (!memcmp(buf+0x10,"\x01\xF4\x03\x00",4)) {
 153         /* Soul Calibur 2 style (type 03) */
 154         DEBUGF("ADX: type 03 found\n");
 155         /* check if header is too small for loop data */
 156         if (chanstart-6 < 0x2c) looping=0;
 157         else {
 158             looping = (buf[0x18]) ||
 159                       (buf[0x19]) ||
 160                       (buf[0x1a]) ||
 161                       (buf[0x1b]);
 162             end_adr = (buf[0x28]<<24) |
 163                       (buf[0x29]<<16) |
 164                       (buf[0x2a]<<8) |
 165                       (buf[0x2b]);
 166
 167             start_adr = (
 168               (buf[0x1c]<<24) |
 169               (buf[0x1d]<<16) |
 170               (buf[0x1e]<<8) |
 171               (buf[0x1f])
 172               )/32*channels*18+chanstart;
 173         }
 174     } else if (!memcmp(buf+0x10,"\x01\xF4\x04\x00",4)) {
 175         /* Standard (type 04) */
 176         DEBUGF("ADX: type 04 found\n");
 177         /* check if header is too small for loop data */
 178         if (chanstart-6 < 0x38) looping=0;
 179         else {
 180             looping = (buf[0x24]) ||
 181                       (buf[0x25]) ||
 182                       (buf[0x26]) ||
 183                       (buf[0x27]);
 184             end_adr = (buf[0x34]<<24) |
 185                       (buf[0x35]<<16) |
 186                       (buf[0x36]<<8) |
 187                       buf[0x37];
 188             start_adr = (
 189               (buf[0x28]<<24) |
 190               (buf[0x29]<<16) |
 191               (buf[0x2a]<<8) |
 192               (buf[0x2b])
 193               )/32*channels*18+chanstart;
 194         }
 195     } else {
 196         DEBUGF("ADX: error, couldn't determine ADX type\n");
 197         return CODEC_ERROR;
 198     }
 199
 200     if (looping) {
 201         DEBUGF("ADX: looped, start: %lx end: %lx\n",start_adr,end_adr);
 202     } else {
 203         DEBUGF("ADX: not looped\n");
 204     }
 205
 206     /* advance to first frame */
 207     DEBUGF("ADX: first frame at %lx\n",chanstart);
 208     bufoff = chanstart;
 209
 210     /* get in position */
 211     ci->seek_buffer(bufoff);
 212
 213
 214     /* setup pcm buffer format */
 215     ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
 216     if (channels == 2) {
 217         ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
 218     } else if (channels == 1) {
 219         ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 220     } else {
 221         DEBUGF("ADX CODEC_ERROR: more than 2 channels\n");
 222         return CODEC_ERROR;
 223     }
 224
 225     endofstream = 0;
 226     loop_count = 0;
 227     fade_count = -1; /* disable fade */
 228     fade_frames = 1;
 229
 230     /* The main decoder loop */
 231
 232     while (!endofstream) {
 233         enum codec_command_action action = ci->get_command(&param);
 234
 235         if (action == CODEC_ACTION_HALT)
 236             break;
 237
 238         /* do we need to loop? */
 239         if (bufoff > end_adr-18*channels && looping) {
 240             DEBUGF("ADX: loop!\n");
 241             /* check for endless looping */
 242             if (ci->global_settings->repeat_mode==REPEAT_ONE) {
 243                 loop_count=0;
 244                 fade_count = -1; /* disable fade */
 245             } else {
 246                 /* otherwise start fade after LOOP_TIMES loops */
 247                 loop_count++;
 248                 if (loop_count >= LOOP_TIMES && fade_count < 0) {
 249                     /* frames to fade over */
 250                     fade_frames = FADE_LENGTH*ci->id3->frequency/32/1000;
 251                     /* volume relative to fade_frames */
 252                     fade_count = fade_frames;
 253                     DEBUGF("ADX: fade_frames = %d\n",fade_frames);
 254                 }
 255             }
 256             bufoff = start_adr;
 257             ci->seek_buffer(bufoff);
 258         }
 259
 260         /* do we need to seek? */
 261         if (action == CODEC_ACTION_SEEK_TIME) {
 262             uint32_t newpos;
 263
 264             DEBUGF("ADX: seek to %ldms\n", (long)param);
 265
 266             endofstream = 0;
 267             loop_count = 0;
 268             fade_count = -1; /* disable fade */
 269             fade_frames = 1;
 270
 271             newpos = (((uint64_t)avgbytespersec*param)
 272                       / (1000LL*18*channels))*(18*channels);
 273             bufoff = chanstart + newpos;
 274             while (bufoff > end_adr-18*channels) {
 275                 bufoff-=end_adr-start_adr;
 276                 loop_count++;
 277             }
 278             ci->seek_buffer(bufoff);
 279             ci->seek_complete();
 280         }
 281
 282         if (bufoff>ci->filesize-channels*18) break; /* End of stream */
 283
 284         sampleswritten=0;
 285
 286         while (
 287                 /* Is there data left in the file? */
 288                 (bufoff <= ci->filesize-(18*channels)) &&
 289                 /* Is there space in the output buffer? */
 290                 (sampleswritten <= WAV_CHUNK_SIZE-(32*channels)) &&
 291                 /* Should we be looping? */
 292                 ((!looping) || bufoff <= end_adr-18*channels))
 293         {
 294             /* decode first/only channel */
 295             int32_t scale;
 296             int32_t ch1_0, d;
 297
 298             /* fetch a frame */
 299             buf = ci->request_buffer(&n, 18);
 300
 301             if (!buf || n!=18) {
 302                 DEBUGF("ADX: couldn't get buffer at %lx\n",
 303                         bufoff);
 304                 return CODEC_ERROR;
 305             }
 306
 307             scale = ((buf[0] << 8) | (buf[1])) +1;
 308
 309             for (i = 2; i < 18; i++)
 310             {
 311                 d = (buf[i] >> 4) & 15;
 312                 if (d & 8) d-= 16;
 313                 ch1_0 = d*scale + ((coef1*ch1_1 + coef2*ch1_2) >> 12);
 314                 if (ch1_0 > 32767) ch1_0 = 32767;
 315                 else if (ch1_0 < -32768) ch1_0 = -32768;
 316                 samples[sampleswritten] = ch1_0;
 317                 sampleswritten+=channels;
 318                 ch1_2 = ch1_1; ch1_1 = ch1_0;
 319
 320                 d = buf[i] & 15;
 321                 if (d & 8) d -= 16;
 322                 ch1_0 = d*scale + ((coef1*ch1_1 + coef2*ch1_2) >> 12);
 323                 if (ch1_0 > 32767) ch1_0 = 32767;
 324                 else if (ch1_0 < -32768) ch1_0 = -32768;
 325                 samples[sampleswritten] = ch1_0;
 326                 sampleswritten+=channels;
 327                 ch1_2 = ch1_1; ch1_1 = ch1_0;
 328             }
 329             bufoff+=18;
 330             ci->advance_buffer(18);
 331
 332             if (channels == 2) {
 333                 /* decode second channel */
 334                 int32_t scale;
 335                 int32_t ch2_0, d;
 336
 337                 buf = ci->request_buffer(&n, 18);
 338
 339                 if (!buf || n!=18) {
 340                     DEBUGF("ADX: couldn't get buffer at %lx\n",
 341                             bufoff);
 342                     return CODEC_ERROR;
 343                 }
 344
 345                 scale = ((buf[0] << 8)|(buf[1]))+1;
 346
 347                 sampleswritten-=63;
 348
 349                 for (i = 2; i < 18; i++)
 350                 {
 351                     d = (buf[i] >> 4) & 15;
 352                     if (d & 8) d-= 16;
 353                     ch2_0 = d*scale + ((coef1*ch2_1 + coef2*ch2_2) >> 12);
 354                     if (ch2_0 > 32767) ch2_0 = 32767;
 355                     else if (ch2_0 < -32768) ch2_0 = -32768;
 356                     samples[sampleswritten] = ch2_0;
 357                     sampleswritten+=2;
 358                     ch2_2 = ch2_1; ch2_1 = ch2_0;
 359
 360                     d = buf[i] & 15;
 361                     if (d & 8) d -= 16;
 362                     ch2_0 = d*scale + ((coef1*ch2_1 + coef2*ch2_2) >> 12);
 363                     if (ch2_0 > 32767) ch2_0 = 32767;
 364                     else if (ch2_0 < -32768) ch2_0 = -32768;
 365                     samples[sampleswritten] = ch2_0;
 366                     sampleswritten+=2;
 367                     ch2_2 = ch2_1; ch2_1 = ch2_0;
 368                 }
 369                 bufoff+=18;
 370                 ci->advance_buffer(18);
 371                 sampleswritten--; /* go back to first channel's next sample */
 372             }
 373
 374             if (fade_count>0) {
 375                 fade_count--;
 376                 for (i=0;i<(channels==1?32:64);i++) samples[sampleswritten-i-1]=
 377                   ((int32_t)samples[sampleswritten-i-1])*fade_count/fade_frames;
 378                 if (fade_count==0) {endofstream=1; break;}
 379             }
 380         }
 381
 382         if (channels == 2)
 383             sampleswritten >>= 1; /* make samples/channel */
 384
 385         ci->pcmbuf_insert(samples, NULL, sampleswritten);
 386
 387         ci->set_elapsed(
 388            ((end_adr-start_adr)*loop_count + bufoff-chanstart)*
 389            1000LL/avgbytespersec);
 390     }
 391
 392     return CODEC_OK;
 393 }