apps/codecs/mpa.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 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/libmad/mad.h>
  24 #include <inttypes.h>
  25
  26 CODEC_HEADER
  27
  28 #if NUM_CORES > 1 && !defined(MPEGPLAYER)
  29 #define MPA_SYNTH_ON_COP
  30 #endif
  31
  32 static struct mad_stream stream IBSS_ATTR;
  33 static struct mad_frame frame IBSS_ATTR;
  34 static struct mad_synth synth IBSS_ATTR;
  35
  36 #ifdef MPA_SYNTH_ON_COP
  37 static volatile short die IBSS_ATTR = 0;          /*thread should die*/
  38
  39 #if (CONFIG_CPU == PP5024) || (CONFIG_CPU == PP5022)
  40 static mad_fixed_t sbsample_prev[2][36][32] IBSS_ATTR;
  41 #else
  42 static mad_fixed_t sbsample_prev[2][36][32] SHAREDBSS_ATTR;
  43 #endif
  44
  45 static struct semaphore synth_done_sem IBSS_ATTR;
  46 static struct semaphore synth_pending_sem IBSS_ATTR;
  47 #endif
  48
  49 #define INPUT_CHUNK_SIZE   8192
  50
  51 static mad_fixed_t mad_frame_overlap[2][32][18] IBSS_ATTR;
  52 static mad_fixed_t sbsample[2][36][32] IBSS_ATTR;
  53
  54 static unsigned char mad_main_data[MAD_BUFFER_MDLEN] IBSS_ATTR;
  55 /* TODO: what latency does layer 1 have? */
  56 static int mpeg_latency[3] = { 0, 481, 529 };
  57 static int mpeg_framesize[3] = {384, 1152, 1152};
  58
  59 static void init_mad(void)
  60 {
  61     ci->memset(&stream, 0, sizeof(struct mad_stream));
  62     ci->memset(&frame , 0, sizeof(struct mad_frame));
  63     ci->memset(&synth , 0, sizeof(struct mad_synth));
  64
  65 #ifdef MPA_SYNTH_ON_COP
  66     frame.sbsample_prev = &sbsample_prev;
  67     frame.sbsample      = &sbsample;
  68 #else
  69     frame.sbsample_prev = &sbsample;
  70     frame.sbsample      = &sbsample;
  71 #endif
  72
  73     /* We do this so libmad doesn't try to call codec_calloc(). This needs to
  74      * be called before mad_stream_init(), mad_frame_inti() and
  75      * mad_synth_init(). */
  76     frame.overlap    = &mad_frame_overlap;
  77     stream.main_data = &mad_main_data;
  78
  79     /* Call mad initialization. Those will zero the arrays frame.overlap,
  80      * frame.sbsample and frame.sbsample_prev. Therefore there is no need to
  81      * zero them here. */
  82     mad_stream_init(&stream);
  83     mad_frame_init(&frame);
  84     mad_synth_init(&synth);
  85 }
  86
  87 static int get_file_pos(int newtime)
  88 {
  89     int pos = -1;
  90     struct mp3entry *id3 = ci->id3;
  91
  92     if (id3->vbr) {
  93         /* Convert newtime and id3->length to seconds to
  94          * avoid overflow */
  95         unsigned int newtime_s = newtime/1000;
  96         unsigned int length_s  = id3->length/1000;
  97
  98         if (id3->has_toc) {
  99             /* Use the TOC to find the new position */
 100             unsigned int percent, remainder;
 101             int curtoc, nexttoc, plen;
 102
 103             percent = (newtime_s*100) / length_s;
 104             if (percent > 99)
 105                 percent = 99;
 106
 107             curtoc = id3->toc[percent];
 108
 109             if (percent < 99) {
 110                 nexttoc = id3->toc[percent+1];
 111             } else {
 112                 nexttoc = 256;
 113             }
 114
 115             pos = (id3->filesize/256)*curtoc;
 116
 117             /* Use the remainder to get a more accurate position */
 118             remainder   = (newtime_s*100) % length_s;
 119             remainder   = (remainder*100) / length_s;
 120             plen        = (nexttoc - curtoc)*(id3->filesize/256);
 121             pos        += (plen/100)*remainder;
 122         } else {
 123             /* No TOC exists, estimate the new position */
 124             pos = (id3->filesize / length_s) * newtime_s;
 125         }
 126     } else if (id3->bitrate) {
 127         pos = newtime * (id3->bitrate / 8);
 128     } else {
 129         return -1;
 130     }
 131
 132     /* Don't seek right to the end of the file so that we can
 133        transition properly to the next song */
 134     if (pos >= (int)(id3->filesize - id3->id3v1len))
 135         pos = id3->filesize - id3->id3v1len - 1;
 136
 137     /* id3->filesize excludes id3->first_frame_offset, so add it now */
 138     pos += id3->first_frame_offset;
 139
 140     return pos;
 141 }
 142
 143 static void set_elapsed(struct mp3entry* id3)
 144 {
 145     unsigned long offset = id3->offset > id3->first_frame_offset ?
 146         id3->offset - id3->first_frame_offset : 0;
 147
 148     if ( id3->vbr ) {
 149         if ( id3->has_toc ) {
 150             /* calculate elapsed time using TOC */
 151             int i;
 152             unsigned int remainder, plen, relpos, nextpos;
 153
 154             /* find wich percent we're at */
 155             for (i=0; i<100; i++ )
 156                 if ( offset < id3->toc[i] * (id3->filesize / 256) )
 157                     break;
 158
 159             i--;
 160             if (i < 0)
 161                 i = 0;
 162
 163             relpos = id3->toc[i];
 164
 165             if (i < 99)
 166                 nextpos = id3->toc[i+1];
 167             else
 168                 nextpos = 256;
 169
 170             remainder = offset - (relpos * (id3->filesize / 256));
 171
 172             /* set time for this percent (divide before multiply to prevent
 173                overflow on long files. loss of precision is negligible on
 174                short files) */
 175             id3->elapsed = i * (id3->length / 100);
 176
 177             /* calculate remainder time */
 178             plen = (nextpos - relpos) * (id3->filesize / 256);
 179             id3->elapsed += (((remainder * 100) / plen) *
 180                              (id3->length / 10000));
 181         }
 182         else {
 183             /* no TOC exists. set a rough estimate using average bitrate */
 184             int tpk = id3->length /
 185                 ((id3->filesize - id3->first_frame_offset - id3->id3v1len) /
 186                 1024);
 187             id3->elapsed = offset / 1024 * tpk;
 188         }
 189     }
 190     else
 191     {
 192         /* constant bitrate, use exact calculation */
 193         if (id3->bitrate != 0)
 194             id3->elapsed = offset / (id3->bitrate / 8);
 195     }
 196 }
 197
 198 #ifdef MPA_SYNTH_ON_COP
 199
 200 /*
 201  * Run the synthesis filter on the COProcessor
 202  */
 203
 204 static int mad_synth_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)] IBSS_ATTR;
 205
 206 static const unsigned char * const mad_synth_thread_name = "mp3dec";
 207 static unsigned int mad_synth_thread_id = 0;
 208
 209
 210 static void mad_synth_thread(void)
 211 {
 212     while(1) {
 213         ci->semaphore_release(&synth_done_sem);
 214         ci->semaphore_wait(&synth_pending_sem);
 215
 216         if(die)
 217             break;
 218
 219         mad_synth_frame(&synth, &frame);
 220     }
 221 }
 222
 223 /* wait for the synth thread to go idle which indicates a PCM frame has been
 224  * synthesized */
 225 static inline void mad_synth_thread_wait_pcm(void)
 226 {
 227     ci->semaphore_wait(&synth_done_sem);
 228 }
 229
 230 /* increment the done semaphore - used after a wait for idle to preserve the
 231  * semaphore count */
 232 static inline void mad_synth_thread_unwait_pcm(void)
 233 {
 234     ci->semaphore_release(&synth_done_sem);
 235 }
 236
 237 /* after synth thread has gone idle - switch decoded frames and commence
 238  * synthesis on it */
 239 static void mad_synth_thread_ready(void)
 240 {
 241     mad_fixed_t (*temp)[2][36][32];
 242
 243     /*circular buffer that holds 2 frames' samples*/
 244     temp=frame.sbsample;
 245     frame.sbsample = frame.sbsample_prev;
 246     frame.sbsample_prev=temp;
 247
 248     ci->semaphore_release(&synth_pending_sem);
 249 }
 250
 251 static bool mad_synth_thread_create(void)
 252 {
 253     ci->semaphore_init(&synth_done_sem, 1, 0);
 254     ci->semaphore_init(&synth_pending_sem, 1, 0);
 255
 256     mad_synth_thread_id = ci->create_thread(mad_synth_thread,
 257                             mad_synth_thread_stack,
 258                             sizeof(mad_synth_thread_stack), 0,
 259                             mad_synth_thread_name
 260                             IF_PRIO(, PRIORITY_PLAYBACK)
 261                             IF_COP(, COP));
 262
 263     if (mad_synth_thread_id == 0)
 264         return false;
 265
 266     return true;
 267 }
 268
 269 static void mad_synth_thread_quit(void)
 270 {
 271     /*mop up COP thread*/
 272     die=1;
 273     ci->semaphore_release(&synth_pending_sem);
 274     ci->thread_wait(mad_synth_thread_id);
 275     ci->cpucache_invalidate();
 276 }
 277 #else
 278 static inline void mad_synth_thread_ready(void)
 279 {
 280      mad_synth_frame(&synth, &frame);
 281 }
 282
 283 static inline bool mad_synth_thread_create(void)
 284 {
 285     return true;
 286 }
 287
 288 static inline void mad_synth_thread_quit(void)
 289 {
 290 }
 291
 292 static inline void mad_synth_thread_wait_pcm(void)
 293 {
 294 }
 295
 296 static inline void mad_synth_thread_unwait_pcm(void)
 297 {
 298 }
 299 #endif /* MPA_SYNTH_ON_COP */
 300
 301 /* this is the codec entry point */
 302 enum codec_status codec_main(void)
 303 {
 304     int status;
 305     size_t size;
 306     int file_end;
 307     int samples_to_skip; /* samples to skip in total for this file (at start) */
 308     char *inputbuffer;
 309     int64_t samplesdone;
 310     int stop_skip, start_skip;
 311     int current_stereo_mode = -1;
 312     unsigned long current_frequency = 0;
 313     int framelength;
 314     int padding = MAD_BUFFER_GUARD; /* to help mad decode the last frame */
 315
 316     if (codec_init())
 317         return CODEC_ERROR;
 318
 319     /* Create a decoder instance */
 320
 321     ci->configure(DSP_SET_SAMPLE_DEPTH, MAD_F_FRACBITS);
 322
 323     /*does nothing on 1 processor systems except return true*/
 324     if(!mad_synth_thread_create())
 325         return CODEC_ERROR;
 326
 327 next_track:
 328
 329     status = CODEC_OK;
 330
 331     /* Reinitializing seems to be necessary to avoid playback quircks when seeking. */
 332     init_mad();
 333
 334     file_end = 0;
 335     while (!*ci->taginfo_ready && !ci->stop_codec)
 336         ci->sleep(1);
 337
 338     ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
 339     current_frequency = ci->id3->frequency;
 340     codec_set_replaygain(ci->id3);
 341
 342     if (ci->id3->offset) {
 343         ci->seek_buffer(ci->id3->offset);
 344         set_elapsed(ci->id3);
 345     }
 346     else
 347         ci->seek_buffer(ci->id3->first_frame_offset);
 348
 349     if (ci->id3->lead_trim >= 0 && ci->id3->tail_trim >= 0) {
 350         stop_skip = ci->id3->tail_trim - mpeg_latency[ci->id3->layer];
 351         if (stop_skip < 0) stop_skip = 0;
 352         start_skip = ci->id3->lead_trim + mpeg_latency[ci->id3->layer];
 353     } else {
 354         stop_skip = 0;
 355         /* We want to skip this amount anyway */
 356         start_skip = mpeg_latency[ci->id3->layer];
 357     }
 358
 359     /* Libmad will not decode the last frame without 8 bytes of extra padding
 360        in the buffer. So, we can trick libmad into not decoding the last frame
 361        if we are to skip it entirely and then cut the appropriate samples from
 362        final frame that we did decode. Note, if all tags (ID3, APE) are not
 363        properly stripped from the end of the file, this trick will not work. */
 364     if (stop_skip >= mpeg_framesize[ci->id3->layer]) {
 365         padding = 0;
 366         stop_skip -= mpeg_framesize[ci->id3->layer];
 367     } else {
 368         padding = MAD_BUFFER_GUARD;
 369     }
 370
 371     samplesdone = ((int64_t)ci->id3->elapsed) * current_frequency / 1000;
 372
 373     /* Don't skip any samples unless we start at the beginning. */
 374     if (samplesdone > 0)
 375         samples_to_skip = 0;
 376     else
 377         samples_to_skip = start_skip;
 378
 379     framelength = 0;
 380
 381     /* This is the decoding loop. */
 382     while (1) {
 383         ci->yield();
 384         if (ci->stop_codec || ci->new_track)
 385             break;
 386
 387         if (ci->seek_time) {
 388             int newpos;
 389
 390             /*make sure the synth thread is idle before seeking - MT only*/
 391             mad_synth_thread_wait_pcm();
 392             mad_synth_thread_unwait_pcm();
 393
 394             samplesdone = ((int64_t)(ci->seek_time-1))*current_frequency/1000;
 395
 396             if (ci->seek_time-1 == 0) {
 397                 newpos = ci->id3->first_frame_offset;
 398                 samples_to_skip = start_skip;
 399             } else {
 400                 newpos = get_file_pos(ci->seek_time-1);
 401                 samples_to_skip = 0;
 402             }
 403
 404             if (!ci->seek_buffer(newpos))
 405                 break;
 406             ci->seek_complete();
 407             init_mad();
 408             framelength = 0;
 409         }
 410
 411         /* Lock buffers */
 412         if (stream.error == 0) {
 413             inputbuffer = ci->request_buffer(&size, INPUT_CHUNK_SIZE);
 414             if (size == 0 || inputbuffer == NULL)
 415                 break;
 416             mad_stream_buffer(&stream, (unsigned char *)inputbuffer,
 417                               size + padding);
 418         }
 419
 420         if (mad_frame_decode(&frame, &stream)) {
 421             if (stream.error == MAD_ERROR_BUFLEN) {
 422                 /* This makes the codec support partially corrupted files */
 423                 if (file_end == 30)
 424                     break;
 425
 426                 /* Fill the buffer */
 427                 if (stream.next_frame)
 428                     ci->advance_buffer_loc((void *)stream.next_frame);
 429                 else
 430                     ci->advance_buffer(size);
 431                 stream.error = 0;
 432                 file_end++;
 433                 continue;
 434             } else if (MAD_RECOVERABLE(stream.error)) {
 435                 continue;
 436             } else {
 437                 /* Some other unrecoverable error */
 438                 status = CODEC_ERROR;
 439                 break;
 440             }
 441             break;
 442         }
 443
 444         file_end = 0;
 445
 446         /* Do the pcmbuf insert here. Note, this is the PREVIOUS frame's pcm
 447            data (not the one just decoded above). When we exit the decoding
 448            loop we will need to process the final frame that was decoded. */
 449         mad_synth_thread_wait_pcm();
 450
 451         if (framelength > 0) {
 452
 453             /* In case of a mono file, the second array will be ignored. */
 454             ci->pcmbuf_insert(&synth.pcm.samples[0][samples_to_skip],
 455                               &synth.pcm.samples[1][samples_to_skip],
 456                               framelength);
 457
 458             /* Only skip samples for the first frame added. */
 459             samples_to_skip = 0;
 460         }
 461
 462         /* Initiate PCM synthesis on the COP (MT) or perform it here (ST) */
 463         mad_synth_thread_ready();
 464
 465         /* Check if sample rate and stereo settings changed in this frame. */
 466         if (frame.header.samplerate != current_frequency) {
 467             current_frequency = frame.header.samplerate;
 468             ci->configure(DSP_SWITCH_FREQUENCY, current_frequency);
 469         }
 470         if (MAD_NCHANNELS(&frame.header) == 2) {
 471             if (current_stereo_mode != STEREO_NONINTERLEAVED) {
 472                 ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
 473                 current_stereo_mode = STEREO_NONINTERLEAVED;
 474             }
 475         } else {
 476             if (current_stereo_mode != STEREO_MONO) {
 477                 ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 478                 current_stereo_mode = STEREO_MONO;
 479             }
 480         }
 481
 482         if (stream.next_frame)
 483             ci->advance_buffer_loc((void *)stream.next_frame);
 484         else
 485             ci->advance_buffer(size);
 486
 487         framelength = synth.pcm.length - samples_to_skip;
 488         if (framelength < 0) {
 489             framelength = 0;
 490             samples_to_skip -= synth.pcm.length;
 491         }
 492
 493         samplesdone += framelength;
 494         ci->set_elapsed((samplesdone * 1000) / current_frequency);
 495     }
 496
 497     /* wait for synth idle - MT only*/
 498     mad_synth_thread_wait_pcm();
 499     mad_synth_thread_unwait_pcm();
 500
 501     /* Finish the remaining decoded frame.
 502        Cut the required samples from the end. */
 503     if (framelength > stop_skip){
 504         ci->pcmbuf_insert(synth.pcm.samples[0], synth.pcm.samples[1],
 505                           framelength - stop_skip);
 506     }
 507
 508     if (ci->request_next_track())
 509         goto next_track;
 510
 511     /*mop up COP thread - MT only*/
 512     mad_synth_thread_quit();
 513
 514     return status;
 515 }