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 struct mad_stream stream IBSS_ATTR;
  33 struct mad_frame frame IBSS_ATTR;
  34 struct mad_synth synth IBSS_ATTR;
  35
  36 #ifdef MPA_SYNTH_ON_COP
  37 volatile short die IBSS_ATTR = 0;          /*thread should die*/
  38
  39 #if (CONFIG_CPU == PP5024) || (CONFIG_CPU == PP5022)
  40 mad_fixed_t sbsample_prev[2][36][32] IBSS_ATTR;
  41 #else
  42 mad_fixed_t sbsample_prev[2][36][32] SHAREDBSS_ATTR;
  43 #endif
  44
  45 struct semaphore synth_done_sem IBSS_ATTR;
  46 struct semaphore synth_pending_sem IBSS_ATTR;
  47 #endif
  48
  49 #define INPUT_CHUNK_SIZE   8192
  50
  51 mad_fixed_t mad_frame_overlap[2][32][18] IBSS_ATTR;
  52 mad_fixed_t sbsample[2][36][32] IBSS_ATTR;
  53
  54 unsigned char mad_main_data[MAD_BUFFER_MDLEN] IBSS_ATTR;
  55 /* TODO: what latency does layer 1 have? */
  56 int mpeg_latency[3] = { 0, 481, 529 };
  57 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_FLAG_INCOMPLETE
 422                 || stream.error == MAD_ERROR_BUFLEN) {
 423                 /* This makes the codec support partially corrupted files */
 424                 if (file_end == 30)
 425                     break;
 426
 427                 /* Fill the buffer */
 428                 if (stream.next_frame)
 429                     ci->advance_buffer_loc((void *)stream.next_frame);
 430                 else
 431                     ci->advance_buffer(size);
 432                 stream.error = 0;
 433                 file_end++;
 434                 continue;
 435             } else if (MAD_RECOVERABLE(stream.error)) {
 436                 continue;
 437             } else {
 438                 /* Some other unrecoverable error */
 439                 status = CODEC_ERROR;
 440                 break;
 441             }
 442             break;
 443         }
 444
 445         file_end = 0;
 446
 447         /* Do the pcmbuf insert here. Note, this is the PREVIOUS frame's pcm
 448            data (not the one just decoded above). When we exit the decoding
 449            loop we will need to process the final frame that was decoded. */
 450         mad_synth_thread_wait_pcm();
 451
 452         if (framelength > 0) {
 453
 454             /* In case of a mono file, the second array will be ignored. */
 455             ci->pcmbuf_insert(&synth.pcm.samples[0][samples_to_skip],
 456                               &synth.pcm.samples[1][samples_to_skip],
 457                               framelength);
 458
 459             /* Only skip samples for the first frame added. */
 460             samples_to_skip = 0;
 461         }
 462
 463         /* Initiate PCM synthesis on the COP (MT) or perform it here (ST) */
 464         mad_synth_thread_ready();
 465
 466         /* Check if sample rate and stereo settings changed in this frame. */
 467         if (frame.header.samplerate != current_frequency) {
 468             current_frequency = frame.header.samplerate;
 469             ci->configure(DSP_SWITCH_FREQUENCY, current_frequency);
 470         }
 471         if (MAD_NCHANNELS(&frame.header) == 2) {
 472             if (current_stereo_mode != STEREO_NONINTERLEAVED) {
 473                 ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
 474                 current_stereo_mode = STEREO_NONINTERLEAVED;
 475             }
 476         } else {
 477             if (current_stereo_mode != STEREO_MONO) {
 478                 ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
 479                 current_stereo_mode = STEREO_MONO;
 480             }
 481         }
 482
 483         if (stream.next_frame)
 484             ci->advance_buffer_loc((void *)stream.next_frame);
 485         else
 486             ci->advance_buffer(size);
 487
 488         framelength = synth.pcm.length - samples_to_skip;
 489         if (framelength < 0) {
 490             framelength = 0;
 491             samples_to_skip -= synth.pcm.length;
 492         }
 493
 494         samplesdone += framelength;
 495         ci->set_elapsed((samplesdone * 1000) / current_frequency);
 496     }
 497
 498     /* wait for synth idle - MT only*/
 499     mad_synth_thread_wait_pcm();
 500     mad_synth_thread_unwait_pcm();
 501
 502     /* Finish the remaining decoded frame.
 503        Cut the required samples from the end. */
 504     if (framelength > stop_skip){
 505         ci->pcmbuf_insert(synth.pcm.samples[0], synth.pcm.samples[1],
 506                           framelength - stop_skip);
 507     }
 508
 509     if (ci->request_next_track())
 510         goto next_track;
 511
 512     /*mop up COP thread - MT only*/
 513     mad_synth_thread_quit();
 514
 515     return status;
 516 }