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