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     ci->debugf("Hello codec");
 316
 317
 318     if (codec_init())
 319         return CODEC_ERROR;
 320
 321     /* Create a decoder instance */
 322
 323     ci->configure(DSP_SET_SAMPLE_DEPTH, MAD_F_FRACBITS);
 324
 325     /*does nothing on 1 processor systems except return true*/
 326     if(!mad_synth_thread_create())
 327         return CODEC_ERROR;
 328
 329 next_track:
 330
 331     status = CODEC_OK;
 332
 333     /* Reinitializing seems to be necessary to avoid playback quircks when seeking. */
 334     init_mad();
 335
 336     file_end = 0;
 337     while (!*ci->taginfo_ready && !ci->stop_codec)
 338         ci->sleep(1);
 339
 340     ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
 341     current_frequency = ci->id3->frequency;
 342     codec_set_replaygain(ci->id3);
 343
 344     if (ci->id3->offset) {
 345         ci->seek_buffer(ci->id3->offset);
 346         set_elapsed(ci->id3);
 347     }
 348     else
 349         ci->seek_buffer(ci->id3->first_frame_offset);
 350
 351     if (ci->id3->lead_trim >= 0 && ci->id3->tail_trim >= 0) {
 352         stop_skip = ci->id3->tail_trim - mpeg_latency[ci->id3->layer];
 353         if (stop_skip < 0) stop_skip = 0;
 354         start_skip = ci->id3->lead_trim + mpeg_latency[ci->id3->layer];
 355     } else {
 356         stop_skip = 0;
 357         /* We want to skip this amount anyway */
 358         start_skip = mpeg_latency[ci->id3->layer];
 359     }
 360
 361     /* Libmad will not decode the last frame without 8 bytes of extra padding
 362        in the buffer. So, we can trick libmad into not decoding the last frame
 363        if we are to skip it entirely and then cut the appropriate samples from
 364        final frame that we did decode. Note, if all tags (ID3, APE) are not
 365        properly stripped from the end of the file, this trick will not work. */
 366     if (stop_skip >= mpeg_framesize[ci->id3->layer]) {
 367         padding = 0;
 368         stop_skip -= mpeg_framesize[ci->id3->layer];
 369     } else {
 370         padding = MAD_BUFFER_GUARD;
 371     }
 372
 373     samplesdone = ((int64_t)ci->id3->elapsed) * current_frequency / 1000;
 374
 375     /* Don't skip any samples unless we start at the beginning. */
 376     if (samplesdone > 0)
 377         samples_to_skip = 0;
 378     else
 379         samples_to_skip = start_skip;
 380
 381     framelength = 0;
 382
 383     /* This is the decoding loop. */
 384     while (1) {
 385         ci->yield();
 386         if (ci->stop_codec || ci->new_track)
 387             break;
 388
 389         if (ci->seek_time) {
 390             int newpos;
 391
 392             /*make sure the synth thread is idle before seeking - MT only*/
 393             mad_synth_thread_wait_pcm();
 394             mad_synth_thread_unwait_pcm();
 395
 396             samplesdone = ((int64_t)(ci->seek_time-1))*current_frequency/1000;
 397
 398             if (ci->seek_time-1 == 0) {
 399                 newpos = ci->id3->first_frame_offset;
 400                 samples_to_skip = start_skip;
 401             } else {
 402                 newpos = get_file_pos(ci->seek_time-1);
 403                 samples_to_skip = 0;
 404             }
 405
 406             if (!ci->seek_buffer(newpos))
 407                 break;
 408             ci->seek_complete();
 409             init_mad();
 410             framelength = 0;
 411         }
 412
 413         /* Lock buffers */
 414         if (stream.error == 0) {
 415             inputbuffer = ci->request_buffer(&size, INPUT_CHUNK_SIZE);
 416             if (size == 0 || inputbuffer == NULL)
 417                 break;
 418             mad_stream_buffer(&stream, (unsigned char *)inputbuffer,
 419                               size + padding);
 420         }
 421
 422         if (mad_frame_decode(&frame, &stream)) {
 423             if (stream.error == MAD_FLAG_INCOMPLETE
 424                 || stream.error == MAD_ERROR_BUFLEN) {
 425                 /* This makes the codec support partially corrupted files */
 426                 if (file_end == 30)
 427                     break;
 428
 429                 /* Fill the buffer */
 430                 if (stream.next_frame)
 431                     ci->advance_buffer_loc((void *)stream.next_frame);
 432                 else
 433                     ci->advance_buffer(size);
 434                 stream.error = 0;
 435                 file_end++;
 436                 continue;
 437             } else if (MAD_RECOVERABLE(stream.error)) {
 438                 continue;
 439             } else {
 440                 /* Some other unrecoverable error */
 441                 status = CODEC_ERROR;
 442                 break;
 443             }
 444             break;
 445         }
 446
 447         file_end = 0;
 448
 449         /* Do the pcmbuf insert here. Note, this is the PREVIOUS frame's pcm
 450            data (not the one just decoded above). When we exit the decoding
 451            loop we will need to process the final frame that was decoded. */
 452         mad_synth_thread_wait_pcm();
 453
 454         if (framelength > 0) {
 455
 456             /* In case of a mono file, the second array will be ignored. */
 457             ci->pcmbuf_insert(&synth.pcm.samples[0][samples_to_skip],
 458                               &synth.pcm.samples[1][samples_to_skip],
 459                               framelength);
 460
 461             /* Only skip samples for the first frame added. */
 462             samples_to_skip = 0;
 463         }
 464
 465         /* Initiate PCM synthesis on the COP (MT) or perform it here (ST) */
 466         mad_synth_thread_ready();
 467
 468         /* Check if sample rate and stereo settings changed in this frame. */
 469         if (frame.header.samplerate != current_frequency) {
 470             current_frequency = frame.header.samplerate;
 471             ci->configure(DSP_SWITCH_FREQUENCY, current_frequency);
 472         }
 473         if (MAD_NCHANNELS(&frame.header) == 2) {
 474             if (current_stereo_mode != STEREO_NONINTERLEAVED) {
 475                 ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
 476                 current_stereo_mode = STEREO_NONINTERLEAVED;
 477             }
 478         } else {
 479             if (current_stereo_mode != STEREO_MONO) {
 480                 ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 481                 current_stereo_mode = STEREO_MONO;
 482             }
 483         }
 484
 485         if (stream.next_frame)
 486             ci->advance_buffer_loc((void *)stream.next_frame);
 487         else
 488             ci->advance_buffer(size);
 489
 490         framelength = synth.pcm.length - samples_to_skip;
 491         if (framelength < 0) {
 492             framelength = 0;
 493             samples_to_skip -= synth.pcm.length;
 494         }
 495
 496         samplesdone += framelength;
 497         ci->set_elapsed((samplesdone * 1000) / current_frequency);
 498     }
 499
 500     /* wait for synth idle - MT only*/
 501     mad_synth_thread_wait_pcm();
 502     mad_synth_thread_unwait_pcm();
 503
 504     /* Finish the remaining decoded frame.
 505        Cut the required samples from the end. */
 506     if (framelength > stop_skip){
 507         ci->pcmbuf_insert(synth.pcm.samples[0], synth.pcm.samples[1],
 508                           framelength - stop_skip);
 509     }
 510
 511     if (ci->request_next_track())
 512         goto next_track;
 513
 514     /*mop up COP thread - MT only*/
 515     mad_synth_thread_quit();
 516
 517     return status;
 518 }