apps/plugins/test_codec.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 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 #include "plugin.h"
  22
  23
  24
  25 /* All swcodec targets have BUTTON_SELECT apart from the H10 and M3 */
  26
  27 #if CONFIG_KEYPAD == IRIVER_H10_PAD
  28 #define TESTCODEC_EXITBUTTON BUTTON_RIGHT
  29 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
  30 #define TESTCODEC_EXITBUTTON BUTTON_RC_PLAY
  31 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
  32 #define TESTCODEC_EXITBUTTON BUTTON_PLAY
  33 #elif CONFIG_KEYPAD == COWON_D2_PAD || CONFIG_KEYPAD == ONDAVX747_PAD
  34 #define TESTCODEC_EXITBUTTON BUTTON_POWER
  35 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
  36 #define TESTCODEC_EXITBUTTON BUTTON_REC
  37 #elif defined(HAVE_TOUCHSCREEN)
  38 #define TESTCODEC_EXITBUTTON BUTTON_TOPLEFT
  39 #else
  40 #define TESTCODEC_EXITBUTTON BUTTON_SELECT
  41 #endif
  42
  43 /* Log functions copied from test_disk.c */
  44 static int line = 0;
  45 static int max_line = 0;
  46 static int log_fd = -1;
  47
  48 static void log_close(void)
  49 {
  50     if (log_fd >= 0)
  51         rb->close(log_fd);
  52 }
  53
  54 static bool log_init(bool use_logfile)
  55 {
  56     int h;
  57     char logfilename[MAX_PATH];
  58
  59     rb->lcd_getstringsize("A", NULL, &h);
  60     max_line = LCD_HEIGHT / h;
  61     line = 0;
  62     rb->lcd_clear_display();
  63     rb->lcd_update();
  64
  65     if (use_logfile) {
  66         log_close();
  67         rb->create_numbered_filename(logfilename, "/", "test_codec_log_", ".txt",
  68                                      2 IF_CNFN_NUM_(, NULL));
  69         log_fd = rb->open(logfilename, O_RDWR|O_CREAT|O_TRUNC, 0666);
  70         return log_fd >= 0;
  71     }
  72
  73     return true;
  74 }
  75
  76 static void log_text(char *text, bool advance)
  77 {
  78     rb->lcd_puts(0, line, text);
  79     rb->lcd_update();
  80     if (advance)
  81     {
  82         if (++line >= max_line)
  83             line = 0;
  84         if (log_fd >= 0)
  85             rb->fdprintf(log_fd, "%s\n", text);
  86     }
  87 }
  88
  89 struct wavinfo_t
  90 {
  91   int fd;
  92   int samplerate;
  93   int channels;
  94   int sampledepth;
  95   int stereomode;
  96   int totalsamples;
  97 };
  98
  99 static void* audiobuf;
 100 static void* codec_mallocbuf;
 101 static size_t audiosize;
 102 static size_t audiobufsize;
 103 static int offset;
 104 static int fd;
 105
 106 /* Our local implementation of the codec API */
 107 static struct codec_api ci;
 108
 109 struct test_track_info {
 110     struct mp3entry id3;       /* TAG metadata */
 111     size_t filesize;           /* File total length */
 112 };
 113
 114 static struct test_track_info track;
 115 static bool taginfo_ready = true;
 116
 117 static bool use_dsp;
 118
 119 static bool checksum;
 120 static uint32_t crc32;
 121
 122 static volatile unsigned int elapsed;
 123 static volatile bool codec_playing;
 124 static volatile long endtick;
 125 static volatile long rebuffertick;
 126 struct wavinfo_t wavinfo;
 127
 128 static unsigned char wav_header[44] =
 129 {
 130     'R','I','F','F',     //  0 - ChunkID
 131      0,0,0,0,            //  4 - ChunkSize (filesize-8)
 132      'W','A','V','E',    //  8 - Format
 133      'f','m','t',' ',    // 12 - SubChunkID
 134      16,0,0,0,           // 16 - SubChunk1ID  // 16 for PCM
 135      1,0,                // 20 - AudioFormat (1=16-bit)
 136      0,0,                // 22 - NumChannels
 137      0,0,0,0,            // 24 - SampleRate in Hz
 138      0,0,0,0,            // 28 - Byte Rate (SampleRate*NumChannels*(BitsPerSample/8)
 139      0,0,                // 32 - BlockAlign (== NumChannels * BitsPerSample/8)
 140      16,0,               // 34 - BitsPerSample
 141      'd','a','t','a',    // 36 - Subchunk2ID
 142      0,0,0,0             // 40 - Subchunk2Size
 143 };
 144
 145 static inline void int2le32(unsigned char* buf, int32_t x)
 146 {
 147   buf[0] = (x & 0xff);
 148   buf[1] = (x & 0xff00) >> 8;
 149   buf[2] = (x & 0xff0000) >> 16;
 150   buf[3] = (x & 0xff000000) >>24;
 151 }
 152
 153 static inline void int2le24(unsigned char* buf, int32_t x)
 154 {
 155   buf[0] = (x & 0xff);
 156   buf[1] = (x & 0xff00) >> 8;
 157   buf[2] = (x & 0xff0000) >> 16;
 158 }
 159
 160 static inline void int2le16(unsigned char* buf, int16_t x)
 161 {
 162   buf[0] = (x & 0xff);
 163   buf[1] = (x & 0xff00) >> 8;
 164 }
 165
 166 static unsigned char *wavbuffer;
 167 static unsigned char *dspbuffer;
 168
 169 void init_wav(char* filename)
 170 {
 171     wavinfo.totalsamples = 0;
 172
 173     wavinfo.fd = rb->creat(filename, 0666);
 174
 175     if (wavinfo.fd >= 0)
 176     {
 177         /* Write WAV header - we go back and fill in the details at the end */
 178         rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
 179     }
 180 }
 181
 182
 183 void close_wav(void)
 184 {
 185     int filesize = rb->filesize(wavinfo.fd);
 186     int channels = (wavinfo.stereomode == STEREO_MONO) ? 1 : 2;
 187     int bps = 16; /* TODO */
 188
 189     /* We assume 16-bit, Stereo */
 190
 191     rb->lseek(wavinfo.fd,0,SEEK_SET);
 192
 193     int2le32(wav_header+4, filesize-8); /* ChunkSize */
 194
 195     int2le16(wav_header+22, channels);
 196
 197     int2le32(wav_header+24, wavinfo.samplerate);
 198
 199     int2le32(wav_header+28, wavinfo.samplerate * channels * (bps / 8)); /* ByteRate */
 200
 201     int2le16(wav_header+32, channels * (bps / 8));
 202
 203     int2le32(wav_header+40, filesize - 44);  /* Subchunk2Size */
 204
 205     rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
 206
 207     rb->close(wavinfo.fd);
 208 }
 209
 210 /* Returns buffer to malloc array. Only codeclib should need this. */
 211 static void* codec_get_buffer(size_t *size)
 212 {
 213    DEBUGF("codec_get_buffer(%"PRIuPTR")\n",(uintptr_t)size);
 214    *size = CODEC_SIZE;
 215    return codec_mallocbuf;
 216 }
 217
 218 static int process_dsp(const void *ch1, const void *ch2, int count)
 219 {
 220     const char *src[2] = { ch1, ch2 };
 221     int written_count = 0;
 222     char *dest = dspbuffer;
 223
 224     while (count > 0)
 225     {
 226         int out_count = rb->dsp_output_count(ci.dsp, count);
 227
 228         int inp_count = rb->dsp_input_count(ci.dsp, out_count);
 229
 230         if (inp_count <= 0)
 231             break;
 232
 233         if (inp_count > count)
 234             inp_count = count;
 235
 236         out_count = rb->dsp_process(ci.dsp, dest, src, inp_count);
 237
 238         if (out_count <= 0)
 239             break;
 240
 241         written_count += out_count;
 242         dest += out_count * 4;
 243
 244         count -= inp_count;
 245     }
 246
 247     return written_count;
 248 }
 249
 250 static inline int32_t clip_sample(int32_t sample)
 251 {
 252     if ((int16_t)sample != sample)
 253         sample = 0x7fff ^ (sample >> 31);
 254
 255     return sample;
 256 }
 257
 258 /* Null output */
 259 static void pcmbuf_insert_null(const void *ch1, const void *ch2, int count)
 260 {
 261     if (use_dsp)
 262         process_dsp(ch1, ch2, count);
 263
 264     /* Prevent idle poweroff */
 265     rb->reset_poweroff_timer();
 266 }
 267
 268 /*
 269  *  Helper function used when the file is larger then the available memory.
 270  *  Rebuffers the file by setting the start of the audio buffer to be
 271  *  new_offset and filling from there.
 272  */
 273 static int fill_buffer(int new_offset){
 274     size_t n, bytestoread;
 275     long temp = *rb->current_tick;
 276     rb->lseek(fd,new_offset,SEEK_SET);
 277
 278     if(new_offset + audiobufsize <= track.filesize)
 279         bytestoread = audiobufsize;
 280     else
 281         bytestoread = track.filesize-new_offset;
 282
 283     n = rb->read(fd, audiobuf,bytestoread);
 284
 285     if (n != bytestoread)
 286     {
 287         log_text("Read failed.",true);
 288         DEBUGF("read fail:  got %d bytes, expected %d\n", (int)n, (int)audiobufsize);
 289         rb->backlight_on();
 290
 291         if (fd >= 0)
 292         {
 293             rb->close(fd);
 294         }
 295
 296         return -1;
 297     }
 298     offset = new_offset;
 299
 300     /*keep track of how much time we spent buffering*/
 301     rebuffertick += *rb->current_tick-temp;
 302
 303     return 0;
 304 }
 305
 306 /* WAV output or calculate crc32 of output*/
 307 static void pcmbuf_insert_wav_checksum(const void *ch1, const void *ch2, int count)
 308 {
 309     const int16_t* data1_16;
 310     const int16_t* data2_16;
 311     const int32_t* data1_32;
 312     const int32_t* data2_32;
 313     unsigned char* p = wavbuffer;
 314     const int scale = wavinfo.sampledepth - 15;
 315     const int dc_bias = 1 << (scale - 1);
 316     int channels = (wavinfo.stereomode == STEREO_MONO) ? 1 : 2;
 317
 318     /* Prevent idle poweroff */
 319     rb->reset_poweroff_timer();
 320
 321     if (use_dsp) {
 322         count = process_dsp(ch1, ch2, count);
 323         wavinfo.totalsamples += count;
 324         if (channels == 1)
 325         {
 326             unsigned char *s = dspbuffer, *d = dspbuffer;
 327             int c = count;
 328             while (c-- > 0)
 329             {
 330                 *d++ = *s++;
 331                 *d++ = *s++;
 332                 s++;
 333                 s++;
 334             }
 335         }
 336         if (checksum)
 337             crc32 = rb->crc_32(dspbuffer, count * 2 * channels, crc32);
 338         else
 339             rb->write(wavinfo.fd, dspbuffer, count * 2 * channels);
 340     }
 341     else
 342     {
 343         if (wavinfo.sampledepth <= 16) {
 344             data1_16 = ch1;
 345             data2_16 = ch2;
 346
 347             switch(wavinfo.stereomode)
 348             {
 349                 case STEREO_INTERLEAVED:
 350                     while (count--) {
 351                         int2le16(p,*data1_16++);
 352                         p += 2;
 353                         int2le16(p,*data1_16++);
 354                         p += 2;
 355                     }
 356                     break;
 357
 358                 case STEREO_NONINTERLEAVED:
 359                     while (count--) {
 360                         int2le16(p,*data1_16++);
 361                         p += 2;
 362                         int2le16(p,*data2_16++);
 363                         p += 2;
 364                     }
 365
 366                     break;
 367
 368                 case STEREO_MONO:
 369                     while (count--) {
 370                         int2le16(p,*data1_16++);
 371                         p += 2;
 372                     }
 373                     break;
 374             }
 375         } else {
 376             data1_32 = ch1;
 377             data2_32 = ch2;
 378
 379             switch(wavinfo.stereomode)
 380             {
 381                 case STEREO_INTERLEAVED:
 382                     while (count--) {
 383                         int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 384                         p += 2;
 385                         int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 386                         p += 2;
 387                     }
 388                     break;
 389
 390                 case STEREO_NONINTERLEAVED:
 391                     while (count--) {
 392                         int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 393                         p += 2;
 394                         int2le16(p, clip_sample((*data2_32++ + dc_bias) >> scale));
 395                         p += 2;
 396                     }
 397
 398                     break;
 399
 400                 case STEREO_MONO:
 401                     while (count--) {
 402                         int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 403                         p += 2;
 404                     }
 405                     break;
 406             }
 407         }
 408
 409         wavinfo.totalsamples += count;
 410         if (checksum)
 411             crc32 = rb->crc_32(wavbuffer, p - wavbuffer, crc32);
 412         else
 413             rb->write(wavinfo.fd, wavbuffer, p - wavbuffer);
 414     } /* else */
 415 }
 416
 417 /* Set song position in WPS (value in ms). */
 418 static void set_elapsed(unsigned long value)
 419 {
 420     elapsed = value;
 421 }
 422
 423
 424 /* Read next <size> amount bytes from file buffer to <ptr>.
 425    Will return number of bytes read or 0 if end of file. */
 426 static size_t read_filebuf(void *ptr, size_t size)
 427 {
 428    if (ci.curpos > (off_t)track.filesize)
 429    {
 430        return 0;
 431    } else {
 432         size_t realsize = MIN(track.filesize-ci.curpos,size);
 433
 434        /* check if we have enough bytes ready*/
 435        if(realsize >(audiobufsize - (ci.curpos-offset)))
 436        {
 437            /*rebuffer so that we start at ci.curpos*/
 438            fill_buffer(ci.curpos);
 439         }
 440
 441        rb->memcpy(ptr, audiobuf + (ci.curpos-offset), realsize);
 442        ci.curpos += realsize;
 443        return realsize;
 444    }
 445 }
 446
 447
 448 /* Request pointer to file buffer which can be used to read
 449    <realsize> amount of data. <reqsize> tells the buffer system
 450    how much data it should try to allocate. If <realsize> is 0,
 451    end of file is reached. */
 452 static void* request_buffer(size_t *realsize, size_t reqsize)
 453 {
 454     *realsize = MIN(track.filesize-ci.curpos,reqsize);
 455
 456     /*check if we have enough bytes ready - requested > bufsize-currentbufpos*/
 457     if(*realsize>(audiobufsize - (ci.curpos-offset)))
 458     {
 459         /*rebuffer so that we start at ci.curpos*/
 460        fill_buffer(ci.curpos);
 461     }
 462
 463     return (audiobuf + (ci.curpos-offset));
 464 }
 465
 466 /* Advance file buffer position by <amount> amount of bytes. */
 467 static void advance_buffer(size_t amount)
 468 {
 469     ci.curpos += amount;
 470 }
 471
 472
 473 /* Advance file buffer to a pointer location inside file buffer. */
 474 static void advance_buffer_loc(void *ptr)
 475 {
 476     ci.curpos = ptr - (audiobuf - offset);
 477 }
 478
 479
 480 /* Seek file buffer to position <newpos> beginning of file. */
 481 static bool seek_buffer(size_t newpos)
 482 {
 483     ci.curpos = newpos;
 484     return true;
 485 }
 486
 487
 488 /* Codec should call this function when it has done the seeking. */
 489 static void seek_complete(void)
 490 {
 491     /* Do nothing */
 492 }
 493
 494 /* Request file change from file buffer. Returns true is next
 495    track is available and changed. If return value is false,
 496    codec should exit immediately with PLUGIN_OK status. */
 497 static bool request_next_track(void)
 498 {
 499     /* We are only decoding a single track */
 500     return false;
 501 }
 502
 503
 504 /* Free the buffer area of the current codec after its loaded */
 505 static void discard_codec(void)
 506 {
 507     /* ??? */
 508 }
 509
 510
 511 static void set_offset(size_t value)
 512 {
 513     /* ??? */
 514     (void)value;
 515 }
 516
 517
 518 /* Configure different codec buffer parameters. */
 519 static void configure(int setting, intptr_t value)
 520 {
 521     if (use_dsp)
 522         rb->dsp_configure(ci.dsp, setting, value);
 523     switch(setting)
 524     {
 525         case DSP_SWITCH_FREQUENCY:
 526         case DSP_SET_FREQUENCY:
 527             DEBUGF("samplerate=%d\n",(int)value);
 528             wavinfo.samplerate = (int)value;
 529             break;
 530
 531         case DSP_SET_SAMPLE_DEPTH:
 532             DEBUGF("sampledepth = %d\n",(int)value);
 533             wavinfo.sampledepth=(int)value;
 534             break;
 535
 536         case DSP_SET_STEREO_MODE:
 537             DEBUGF("Stereo mode = %d\n",(int)value);
 538             wavinfo.stereomode=(int)value;
 539             break;
 540     }
 541
 542 }
 543
 544 static void init_ci(void)
 545 {
 546     /* --- Our "fake" implementations of the codec API functions. --- */
 547
 548     ci.codec_get_buffer = codec_get_buffer;
 549
 550     if (wavinfo.fd >= 0 || checksum) {
 551         ci.pcmbuf_insert = pcmbuf_insert_wav_checksum;
 552     } else {
 553         ci.pcmbuf_insert = pcmbuf_insert_null;
 554     }
 555
 556     ci.set_elapsed = set_elapsed;
 557     ci.read_filebuf = read_filebuf;
 558     ci.request_buffer = request_buffer;
 559     ci.advance_buffer = advance_buffer;
 560     ci.advance_buffer_loc = advance_buffer_loc;
 561     ci.seek_buffer = seek_buffer;
 562     ci.seek_complete = seek_complete;
 563     ci.request_next_track = request_next_track;
 564     ci.discard_codec = discard_codec;
 565     ci.set_offset = set_offset;
 566     ci.configure = configure;
 567     ci.dsp = (struct dsp_config *)rb->dsp_configure(NULL, DSP_MYDSP,
 568                                                     CODEC_IDX_AUDIO);
 569
 570     /* --- "Core" functions --- */
 571
 572     /* kernel/ system */
 573     ci.sleep = rb->sleep;
 574     ci.yield = rb->yield;
 575
 576     /* strings and memory */
 577     ci.strcpy = rb->strcpy;
 578     ci.strlen = rb->strlen;
 579     ci.strcmp = rb->strcmp;
 580     ci.strcat = rb->strcat;
 581     ci.memset = rb->memset;
 582     ci.memcpy = rb->memcpy;
 583     ci.memmove = rb->memmove;
 584     ci.memcmp = rb->memcmp;
 585     ci.memchr = rb->memchr;
 586     ci.strcasestr = rb->strcasestr;
 587 #if defined(DEBUG) || defined(SIMULATOR)
 588     ci.debugf = rb->debugf;
 589 #endif
 590 #ifdef ROCKBOX_HAS_LOGF
 591     ci.logf = rb->logf;
 592 #endif
 593
 594     ci.qsort = rb->qsort;
 595     ci.global_settings = rb->global_settings;
 596
 597 #ifdef RB_PROFILE
 598     ci.profile_thread = rb->profile_thread;
 599     ci.profstop = rb->profstop;
 600     ci.profile_func_enter = rb->profile_func_enter;
 601     ci.profile_func_exit = rb->profile_func_exit;
 602 #endif
 603
 604     ci.cpucache_invalidate = rb->cpucache_invalidate;
 605     ci.cpucache_flush = rb->cpucache_flush;
 606
 607 #if NUM_CORES > 1
 608     ci.create_thread = rb->create_thread;
 609     ci.thread_thaw = rb->thread_thaw;
 610     ci.thread_wait = rb->thread_wait;
 611     ci.semaphore_init = rb->semaphore_init;
 612     ci.semaphore_wait = rb->semaphore_wait;
 613     ci.semaphore_release = rb->semaphore_release;
 614 #endif
 615
 616 #if defined(CPU_ARM) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
 617     ci.__div0 = rb->__div0;
 618 #endif
 619 }
 620
 621 static void codec_thread(void)
 622 {
 623     const char* codecname;
 624     int res;
 625
 626     codecname = rb->get_codec_filename(track.id3.codectype);
 627
 628     /* Load the codec and start decoding. */
 629     res = rb->codec_load_file(codecname,&ci);
 630
 631     /* Signal to the main thread that we are done */
 632     endtick = *rb->current_tick - rebuffertick;
 633     codec_playing = false;
 634 }
 635
 636 static enum plugin_status test_track(const char* filename)
 637 {
 638     size_t n;
 639     enum plugin_status res = PLUGIN_ERROR;
 640     long starttick;
 641     long ticks;
 642     unsigned long speed;
 643     unsigned long duration;
 644     const char* ch;
 645     char str[MAX_PATH];
 646     offset=0;
 647
 648     /* Display filename (excluding any path)*/
 649     ch = rb->strrchr(filename, '/');
 650     if (ch==NULL)
 651        ch = filename;
 652     else
 653        ch++;
 654
 655     rb->snprintf(str,sizeof(str),"%s",ch);
 656     log_text(str,true);
 657
 658     log_text("Loading...",false);
 659
 660     fd = rb->open(filename,O_RDONLY);
 661     if (fd < 0)
 662     {
 663         log_text("Cannot open file",true);
 664         goto exit;
 665     }
 666
 667     track.filesize = rb->filesize(fd);
 668
 669     /* Clear the id3 struct */
 670     rb->memset(&track.id3, 0, sizeof(struct mp3entry));
 671
 672     if (!rb->get_metadata(&(track.id3), fd, filename))
 673     {
 674         log_text("Cannot read metadata",true);
 675         goto exit;
 676     }
 677
 678     if (track.filesize > audiosize)
 679     {
 680         audiobufsize=audiosize;
 681
 682     } else
 683     {
 684         audiobufsize=track.filesize;
 685     }
 686
 687     n = rb->read(fd, audiobuf, audiobufsize);
 688
 689     if (n != audiobufsize)
 690     {
 691         log_text("Read failed.",true);
 692         goto exit;
 693     }
 694
 695
 696     /* Initialise the function pointers in the codec API */
 697     init_ci();
 698
 699     /* Prepare the codec struct for playing the whole file */
 700     ci.filesize = track.filesize;
 701     ci.id3 = &track.id3;
 702     ci.taginfo_ready = &taginfo_ready;
 703     ci.curpos = 0;
 704     ci.stop_codec = false;
 705     ci.new_track = 0;
 706     ci.seek_time = 0;
 707
 708     if (use_dsp)
 709         rb->dsp_configure(ci.dsp, DSP_RESET, 0);
 710
 711     if (checksum)
 712         crc32 = 0xffffffff;
 713
 714     rebuffertick=0;
 715     starttick = *rb->current_tick;
 716
 717     codec_playing = true;
 718
 719     rb->codec_thread_do_callback(codec_thread, NULL);
 720
 721     /* Wait for codec thread to die */
 722     while (codec_playing)
 723     {
 724         rb->sleep(HZ);
 725         rb->snprintf(str,sizeof(str),"%d of %d",elapsed,(int)track.id3.length);
 726         log_text(str,false);
 727     }
 728     ticks = endtick - starttick;
 729
 730     /* Be sure it is done */
 731     rb->codec_thread_do_callback(NULL, NULL);
 732     rb->backlight_on();
 733     log_text(str,true);
 734
 735     if (checksum)
 736     {
 737         rb->snprintf(str, sizeof(str), "CRC32 - %08x", (unsigned)crc32);
 738         log_text(str,true);
 739     }
 740     else if (wavinfo.fd < 0)
 741     {
 742         /* Display benchmark information */
 743         rb->snprintf(str,sizeof(str),"Decode time - %d.%02ds",(int)ticks/100,(int)ticks%100);
 744         log_text(str,true);
 745
 746         duration = track.id3.length / 10;
 747         rb->snprintf(str,sizeof(str),"File duration - %d.%02ds",(int)duration/100,(int)duration%100);
 748         log_text(str,true);
 749
 750         if (ticks > 0)
 751             speed = duration * 10000 / ticks;
 752         else
 753             speed = 0;
 754
 755         rb->snprintf(str,sizeof(str),"%d.%02d%% realtime",(int)speed/100,(int)speed%100);
 756         log_text(str,true);
 757
 758 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 759         /* show effective clockrate in MHz needed for realtime decoding */
 760         if (speed > 0)
 761         {
 762             speed = CPUFREQ_MAX / speed;
 763             rb->snprintf(str,sizeof(str),"%d.%02dMHz needed for realtime",
 764             (int)speed/100,(int)speed%100);
 765             log_text(str,true);
 766         }
 767 #endif
 768     }
 769
 770     res = PLUGIN_OK;
 771
 772 exit:
 773     rb->backlight_on();
 774
 775     if (fd >= 0)
 776     {
 777         rb->close(fd);
 778     }
 779
 780     return res;
 781 }
 782
 783 /* plugin entry point */
 784 enum plugin_status plugin_start(const void* parameter)
 785 {
 786     int result, selection = 0;
 787     enum plugin_status res = PLUGIN_OK;
 788     int scandir;
 789     struct dirent *entry;
 790     DIR* dir;
 791     char* ch;
 792     char dirpath[MAX_PATH];
 793     char filename[MAX_PATH];
 794     size_t buffer_size;
 795
 796     if (parameter == NULL)
 797     {
 798         rb->splash(HZ*2, "No File");
 799         return PLUGIN_ERROR;
 800     }
 801
 802     wavbuffer = rb->plugin_get_buffer(&buffer_size);
 803     dspbuffer = wavbuffer + buffer_size / 2;
 804
 805     codec_mallocbuf = rb->plugin_get_audio_buffer(&audiosize);
 806     audiobuf = SKIPBYTES(codec_mallocbuf, CODEC_SIZE);
 807     audiosize -= CODEC_SIZE;
 808
 809 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 810     rb->cpu_boost(true);
 811 #endif
 812     rb->lcd_clear_display();
 813     rb->lcd_update();
 814
 815     enum
 816     {
 817         SPEED_TEST = 0,
 818         SPEED_TEST_DIR,
 819         WRITE_WAV,
 820         SPEED_TEST_WITH_DSP,
 821         SPEED_TEST_DIR_WITH_DSP,
 822         WRITE_WAV_WITH_DSP,
 823         CHECKSUM,
 824         CHECKSUM_DIR,
 825         QUIT,
 826     };
 827
 828     MENUITEM_STRINGLIST(
 829         menu, "test_codec", NULL,
 830         "Speed test",
 831         "Speed test folder",
 832         "Write WAV",
 833         "Speed test with DSP",
 834         "Speed test folder with DSP",
 835         "Write WAV with DSP",
 836         "Checksum",
 837         "Checksum folder",
 838         "Quit",
 839     );
 840
 841 show_menu:
 842     rb->lcd_clear_display();
 843
 844     result = rb->do_menu(&menu, &selection, NULL, false);
 845
 846     if (result == QUIT)
 847     {
 848         res = PLUGIN_OK;
 849         goto exit;
 850     }
 851
 852     scandir = 0;
 853
 854     if ((checksum = (result == CHECKSUM || result == CHECKSUM_DIR)))
 855         result -= 6;
 856
 857     if ((use_dsp = ((result >= SPEED_TEST_WITH_DSP)
 858                    && (result <= WRITE_WAV_WITH_DSP)))) {
 859         result -= 3;
 860     }
 861     if (result == SPEED_TEST) {
 862         wavinfo.fd = -1;
 863         log_init(false);
 864     } else if (result == SPEED_TEST_DIR) {
 865         wavinfo.fd = -1;
 866         scandir = 1;
 867
 868         /* Only create a log file when we are testing a folder */
 869         if (!log_init(true)) {
 870             rb->splash(HZ*2, "Cannot create logfile");
 871             res = PLUGIN_ERROR;
 872             goto exit;
 873         }
 874     } else if (result == WRITE_WAV) {
 875         log_init(false);
 876         init_wav("/test.wav");
 877         if (wavinfo.fd < 0) {
 878             rb->splash(HZ*2, "Cannot create /test.wav");
 879             res = PLUGIN_ERROR;
 880             goto exit;
 881         }
 882     } else if (result == MENU_ATTACHED_USB) {
 883         res = PLUGIN_USB_CONNECTED;
 884         goto exit;
 885     } else if (result < 0) {
 886         res = PLUGIN_OK;
 887         goto exit;
 888     }
 889
 890     if (scandir) {
 891         /* Test all files in the same directory as the file selected by the
 892            user */
 893
 894         rb->strlcpy(dirpath,parameter,sizeof(dirpath));
 895         ch = rb->strrchr(dirpath,'/');
 896         ch[1]=0;
 897
 898         DEBUGF("Scanning directory \"%s\"\n",dirpath);
 899         dir = rb->opendir(dirpath);
 900         if (dir) {
 901             entry = rb->readdir(dir);
 902             while (entry) {
 903                 struct dirinfo info = rb->dir_get_info(dir, entry);
 904                 if (!(info.attribute & ATTR_DIRECTORY)) {
 905                     rb->snprintf(filename,sizeof(filename),"%s%s",dirpath,entry->d_name);
 906                     test_track(filename);
 907                     log_text("", true);
 908                 }
 909
 910                 /* Read next entry */
 911                 entry = rb->readdir(dir);
 912             }
 913
 914             rb->closedir(dir);
 915         }
 916     } else {
 917         /* Just test the file */
 918         res = test_track(parameter);
 919
 920         /* Close WAV file (if there was one) */
 921         if (wavinfo.fd >= 0) {
 922             close_wav();
 923             log_text("Wrote /test.wav",true);
 924         }
 925         while (rb->button_get(true) != TESTCODEC_EXITBUTTON);
 926     }
 927     rb->button_clear_queue();
 928     goto show_menu;
 929
 930 exit:
 931     log_close();
 932
 933 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 934     rb->cpu_boost(false);
 935 #endif
 936
 937     return res;
 938 }