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 PLUGIN_HEADER
  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 == COWOND2_PAD
  32 #define TESTCODEC_EXITBUTTON BUTTON_POWER
  33 #else
  34 #define TESTCODEC_EXITBUTTON BUTTON_SELECT
  35 #endif
  36
  37 static const struct plugin_api* rb;
  38
  39 CACHE_FUNCTION_WRAPPERS(rb)
  40
  41 /* Log functions copied from test_disk.c */
  42 static int line = 0;
  43 static int max_line = 0;
  44 static int log_fd = -1;
  45 static char logfilename[MAX_PATH];
  46
  47 static bool log_init(bool use_logfile)
  48 {
  49     int h;
  50
  51     rb->lcd_getstringsize("A", NULL, &h);
  52     max_line = LCD_HEIGHT / h;
  53     line = 0;
  54     rb->lcd_clear_display();
  55     rb->lcd_update();
  56
  57     if (use_logfile) {
  58         rb->create_numbered_filename(logfilename, "/", "test_codec_log_", ".txt",
  59                                      2 IF_CNFN_NUM_(, NULL));
  60         log_fd = rb->open(logfilename, O_RDWR|O_CREAT|O_TRUNC);
  61         return log_fd >= 0;
  62     }
  63
  64     return true;
  65 }
  66
  67 static void log_text(char *text, bool advance)
  68 {
  69     rb->lcd_puts(0, line, text);
  70     rb->lcd_update();
  71     if (advance)
  72     {
  73         if (++line >= max_line)
  74             line = 0;
  75         if (log_fd >= 0)
  76             rb->fdprintf(log_fd, "%s\n", text);
  77     }
  78 }
  79
  80 static void log_close(void)
  81 {
  82     if (log_fd >= 0)
  83         rb->close(log_fd);
  84 }
  85
  86 struct wavinfo_t
  87 {
  88   int fd;
  89   int samplerate;
  90   int channels;
  91   int sampledepth;
  92   int stereomode;
  93   int totalsamples;
  94 };
  95
  96 static void* audiobuf;
  97 static void* codec_mallocbuf;
  98 static size_t audiosize;
  99 static char str[MAX_PATH];
 100
 101 /* Our local implementation of the codec API */
 102 static struct codec_api ci;
 103
 104 struct test_track_info {
 105     struct mp3entry id3;       /* TAG metadata */
 106     size_t filesize;           /* File total length */
 107 };
 108
 109 static struct test_track_info track;
 110 static bool taginfo_ready = true;
 111
 112 static volatile unsigned int elapsed;
 113 static volatile bool codec_playing;
 114 struct wavinfo_t wavinfo;
 115
 116 static unsigned char wav_header[44] =
 117 {
 118     'R','I','F','F',     //  0 - ChunkID
 119      0,0,0,0,            //  4 - ChunkSize (filesize-8)
 120      'W','A','V','E',    //  8 - Format
 121      'f','m','t',' ',    // 12 - SubChunkID
 122      16,0,0,0,           // 16 - SubChunk1ID  // 16 for PCM
 123      1,0,                // 20 - AudioFormat (1=16-bit)
 124      0,0,                // 22 - NumChannels
 125      0,0,0,0,            // 24 - SampleRate in Hz
 126      0,0,0,0,            // 28 - Byte Rate (SampleRate*NumChannels*(BitsPerSample/8)
 127      0,0,                // 32 - BlockAlign (== NumChannels * BitsPerSample/8)
 128      16,0,               // 34 - BitsPerSample
 129      'd','a','t','a',    // 36 - Subchunk2ID
 130      0,0,0,0             // 40 - Subchunk2Size
 131 };
 132
 133 static inline void int2le32(unsigned char* buf, int32_t x)
 134 {
 135   buf[0] = (x & 0xff);
 136   buf[1] = (x & 0xff00) >> 8;
 137   buf[2] = (x & 0xff0000) >> 16;
 138   buf[3] = (x & 0xff000000) >>24;
 139 }
 140
 141 static inline void int2le24(unsigned char* buf, int32_t x)
 142 {
 143   buf[0] = (x & 0xff);
 144   buf[1] = (x & 0xff00) >> 8;
 145   buf[2] = (x & 0xff0000) >> 16;
 146 }
 147
 148 static inline void int2le16(unsigned char* buf, int16_t x)
 149 {
 150   buf[0] = (x & 0xff);
 151   buf[1] = (x & 0xff00) >> 8;
 152 }
 153
 154 void init_wav(char* filename)
 155 {
 156     wavinfo.totalsamples = 0;
 157
 158     wavinfo.fd = rb->creat(filename);
 159
 160     if (wavinfo.fd >= 0)
 161     {
 162         /* Write WAV header - we go back and fill in the details at the end */
 163         rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
 164     }
 165 }
 166
 167
 168 void close_wav(void) {
 169   int filesize = rb->filesize(wavinfo.fd);
 170   int channels = (wavinfo.stereomode == STEREO_MONO) ? 1 : 2;
 171   int bps = 16; /* TODO */
 172
 173   /* We assume 16-bit, Stereo */
 174
 175   rb->lseek(wavinfo.fd,0,SEEK_SET);
 176
 177   int2le32(wav_header+4, filesize-8); /* ChunkSize */
 178
 179   int2le16(wav_header+22, channels);
 180
 181   int2le32(wav_header+24, wavinfo.samplerate);
 182
 183   int2le32(wav_header+28, wavinfo.samplerate * channels * (bps / 8)); /* ByteRate */
 184
 185   int2le16(wav_header+32, channels * (bps / 8));
 186
 187   int2le32(wav_header+40, filesize - 44);  /* Subchunk2Size */
 188
 189   rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
 190
 191   rb->close(wavinfo.fd);
 192 }
 193
 194 /* Returns buffer to malloc array. Only codeclib should need this. */
 195 static void* get_codec_memory(size_t *size)
 196 {
 197    DEBUGF("get_codec_memory(%d)\n",(int)size);
 198    *size = 512*1024;
 199    return codec_mallocbuf;
 200 }
 201
 202 /* Null output */
 203 static bool pcmbuf_insert_null(const void *ch1, const void *ch2, int count)
 204 {
 205     /* Always successful - just discard data */
 206     (void)ch1;
 207     (void)ch2;
 208     (void)count;
 209
 210     /* Prevent idle poweroff */
 211     rb->reset_poweroff_timer();
 212
 213     return true;
 214 }
 215
 216 /* 64KB should be enough */
 217 static unsigned char wavbuffer[64*1024];
 218
 219 static inline int32_t clip_sample(int32_t sample)
 220 {
 221     if ((int16_t)sample != sample)
 222         sample = 0x7fff ^ (sample >> 31);
 223
 224     return sample;
 225 }
 226
 227
 228 /* WAV output */
 229 static bool pcmbuf_insert_wav(const void *ch1, const void *ch2, int count)
 230 {
 231     const int16_t* data1_16;
 232     const int16_t* data2_16;
 233     const int32_t* data1_32;
 234     const int32_t* data2_32;
 235     unsigned char* p = wavbuffer;
 236     const int scale = wavinfo.sampledepth - 15;
 237     const int dc_bias = 1 << (scale - 1);
 238
 239     /* Prevent idle poweroff */
 240     rb->reset_poweroff_timer();
 241
 242     if (wavinfo.sampledepth <= 16) {
 243         data1_16 = ch1;
 244         data2_16 = ch2;
 245
 246         switch(wavinfo.stereomode)
 247         {
 248             case STEREO_INTERLEAVED:
 249                 while (count--) {
 250                     int2le16(p,*data1_16++);
 251                     p += 2;
 252                     int2le16(p,*data1_16++);
 253                     p += 2;
 254                 }
 255                 break;
 256
 257             case STEREO_NONINTERLEAVED:
 258                 while (count--) {
 259                     int2le16(p,*data1_16++);
 260                     p += 2;
 261                     int2le16(p,*data2_16++);
 262                     p += 2;
 263                 }
 264
 265                 break;
 266
 267             case STEREO_MONO:
 268                 while (count--) {
 269                     int2le16(p,*data1_16++);
 270                     p += 2;
 271                 }
 272                 break;
 273         }
 274     } else {
 275         data1_32 = ch1;
 276         data2_32 = ch2;
 277
 278         switch(wavinfo.stereomode)
 279         {
 280             case STEREO_INTERLEAVED:
 281                 while (count--) {
 282                     int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 283                     p += 2;
 284                     int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 285                     p += 2;
 286                 }
 287                 break;
 288
 289             case STEREO_NONINTERLEAVED:
 290                 while (count--) {
 291                     int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 292                     p += 2;
 293                     int2le16(p, clip_sample((*data2_32++ + dc_bias) >> scale));
 294                     p += 2;
 295                 }
 296
 297                 break;
 298
 299             case STEREO_MONO:
 300                 while (count--) {
 301                     int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
 302                     p += 2;
 303                 }
 304                 break;
 305         }
 306     }
 307
 308     wavinfo.totalsamples += count;
 309     rb->write(wavinfo.fd, wavbuffer, p - wavbuffer);
 310
 311     return true;
 312 }
 313
 314
 315 /* Set song position in WPS (value in ms). */
 316 static void set_elapsed(unsigned int value)
 317 {
 318     elapsed = value;
 319 }
 320
 321
 322 /* Read next <size> amount bytes from file buffer to <ptr>.
 323    Will return number of bytes read or 0 if end of file. */
 324 static size_t read_filebuf(void *ptr, size_t size)
 325 {
 326    if (ci.curpos > (off_t)track.filesize)
 327    {
 328        return 0;
 329    } else {
 330        /* TODO: Don't read beyond end of buffer */
 331        rb->memcpy(ptr, audiobuf + ci.curpos, size);
 332        ci.curpos += size;
 333        return size;
 334    }
 335 }
 336
 337
 338 /* Request pointer to file buffer which can be used to read
 339    <realsize> amount of data. <reqsize> tells the buffer system
 340    how much data it should try to allocate. If <realsize> is 0,
 341    end of file is reached. */
 342 static void* request_buffer(size_t *realsize, size_t reqsize)
 343 {
 344     *realsize = MIN(track.filesize-ci.curpos,reqsize);
 345
 346     return (audiobuf + ci.curpos);
 347 }
 348
 349
 350 /* Advance file buffer position by <amount> amount of bytes. */
 351 static void advance_buffer(size_t amount)
 352 {
 353     ci.curpos += amount;
 354 }
 355
 356
 357 /* Advance file buffer to a pointer location inside file buffer. */
 358 static void advance_buffer_loc(void *ptr)
 359 {
 360     ci.curpos = ptr - audiobuf;
 361 }
 362
 363
 364 /* Seek file buffer to position <newpos> beginning of file. */
 365 static bool seek_buffer(size_t newpos)
 366 {
 367     ci.curpos = newpos;
 368     return true;
 369 }
 370
 371
 372 /* Codec should call this function when it has done the seeking. */
 373 static void seek_complete(void)
 374 {
 375     /* Do nothing */
 376 }
 377
 378 /* Request file change from file buffer. Returns true is next
 379    track is available and changed. If return value is false,
 380    codec should exit immediately with PLUGIN_OK status. */
 381 static bool request_next_track(void)
 382 {
 383     /* We are only decoding a single track */
 384     return false;
 385 }
 386
 387
 388 /* Free the buffer area of the current codec after its loaded */
 389 static void discard_codec(void)
 390 {
 391     /* ??? */
 392 }
 393
 394
 395 static void set_offset(size_t value)
 396 {
 397     /* ??? */
 398     (void)value;
 399 }
 400
 401
 402 /* Configure different codec buffer parameters. */
 403 static void configure(int setting, intptr_t value)
 404 {
 405     switch(setting)
 406     {
 407         case DSP_SWITCH_FREQUENCY:
 408         case DSP_SET_FREQUENCY:
 409             DEBUGF("samplerate=%d\n",(int)value);
 410             wavinfo.samplerate = (int)value;
 411             break;
 412
 413         case DSP_SET_SAMPLE_DEPTH:
 414             DEBUGF("sampledepth = %d\n",(int)value);
 415             wavinfo.sampledepth=(int)value;
 416             break;
 417
 418         case DSP_SET_STEREO_MODE:
 419             DEBUGF("Stereo mode = %d\n",(int)value);
 420             wavinfo.stereomode=(int)value;
 421             break;
 422     }
 423
 424 }
 425
 426 static void init_ci(void)
 427 {
 428     /* --- Our "fake" implementations of the codec API functions. --- */
 429
 430     ci.get_codec_memory = get_codec_memory;
 431
 432     if (wavinfo.fd >= 0) {
 433         ci.pcmbuf_insert = pcmbuf_insert_wav;
 434     } else {
 435         ci.pcmbuf_insert = pcmbuf_insert_null;
 436     }
 437     ci.set_elapsed = set_elapsed;
 438     ci.read_filebuf = read_filebuf;
 439     ci.request_buffer = request_buffer;
 440     ci.advance_buffer = advance_buffer;
 441     ci.advance_buffer_loc = advance_buffer_loc;
 442     ci.seek_buffer = seek_buffer;
 443     ci.seek_complete = seek_complete;
 444     ci.request_next_track = request_next_track;
 445     ci.discard_codec = discard_codec;
 446     ci.set_offset = set_offset;
 447     ci.configure = configure;
 448
 449     /* --- "Core" functions --- */
 450
 451     /* kernel/ system */
 452     ci.PREFIX(sleep) = rb->PREFIX(sleep);
 453     ci.yield = rb->yield;
 454
 455     /* strings and memory */
 456     ci.strcpy = rb->strcpy;
 457     ci.strncpy = rb->strncpy;
 458     ci.strlen = rb->strlen;
 459     ci.strcmp = rb->strcmp;
 460     ci.strcat = rb->strcat;
 461     ci.memset = rb->memset;
 462     ci.memcpy = rb->memcpy;
 463     ci.memmove = rb->memmove;
 464     ci.memcmp = rb->memcmp;
 465     ci.memchr = rb->memchr;
 466
 467 #if defined(DEBUG) || defined(SIMULATOR)
 468     ci.debugf = rb->debugf;
 469 #endif
 470 #ifdef ROCKBOX_HAS_LOGF
 471     ci.logf = rb->logf;
 472 #endif
 473
 474     ci.qsort = rb->qsort;
 475     ci.global_settings = rb->global_settings;
 476
 477 #ifdef RB_PROFILE
 478     ci.profile_thread = rb->profile_thread;
 479     ci.profstop = rb->profstop;
 480     ci.profile_func_enter = rb->profile_func_enter;
 481     ci.profile_func_exit = rb->profile_func_exit;
 482 #endif
 483
 484 #ifdef CACHE_FUNCTIONS_AS_CALL
 485     ci.invalidate_icache = invalidate_icache;
 486     ci.flush_icache = flush_icache;
 487 #endif
 488 }
 489
 490 static void codec_thread(void)
 491 {
 492     const char* codecname;
 493     int res;
 494
 495     codecname = rb->get_codec_filename(track.id3.codectype);
 496
 497     /* Load the codec and start decoding. */
 498     res = rb->codec_load_file(codecname,&ci);
 499
 500     /* Signal to the main thread that we are done */
 501     codec_playing = false;
 502 }
 503
 504 static uintptr_t* codec_stack;
 505 static size_t codec_stack_size;
 506
 507 static enum plugin_status test_track(const char* filename)
 508 {
 509     size_t n;
 510     int fd;
 511     enum plugin_status res = PLUGIN_ERROR;
 512     unsigned long starttick;
 513     unsigned long ticks;
 514     unsigned long speed;
 515     unsigned long duration;
 516     struct thread_entry* codecthread_id;
 517     const char* ch;
 518
 519     /* Display filename (excluding any path)*/
 520     ch = rb->strrchr(filename, '/');
 521     if (ch==NULL)
 522        ch = filename;
 523     else
 524        ch++;
 525
 526     rb->snprintf(str,sizeof(str),"%s",ch);
 527     log_text(str,true);
 528
 529     log_text("Loading...",false);
 530
 531     fd = rb->open(filename,O_RDONLY);
 532     if (fd < 0)
 533     {
 534         log_text("Cannot open file",true);
 535         goto exit;
 536     }
 537
 538     track.filesize = rb->filesize(fd);
 539
 540     /* Clear the id3 struct */
 541     rb->memset(&track.id3, 0, sizeof(struct mp3entry));
 542
 543     if (!rb->get_metadata(&(track.id3), fd, filename))
 544     {
 545         log_text("Cannot read metadata",true);
 546         goto exit;
 547     }
 548
 549     if (track.filesize > audiosize)
 550     {
 551         log_text("File too large",true);
 552         goto exit;
 553     }
 554
 555     n = rb->read(fd, audiobuf, track.filesize);
 556
 557     if (n != track.filesize)
 558     {
 559         log_text("Read failed.",true);
 560         goto exit;
 561     }
 562
 563     /* Initialise the function pointers in the codec API */
 564     init_ci();
 565
 566     /* Prepare the codec struct for playing the whole file */
 567     ci.filesize = track.filesize;
 568     ci.id3 = &track.id3;
 569     ci.taginfo_ready = &taginfo_ready;
 570     ci.curpos = 0;
 571     ci.stop_codec = false;
 572     ci.new_track = 0;
 573     ci.seek_time = 0;
 574
 575     starttick = *rb->current_tick;
 576
 577     codec_playing = true;
 578
 579     if ((codecthread_id = rb->create_thread(codec_thread,
 580             codec_stack, codec_stack_size, 0, "testcodec"
 581             IF_PRIO(,PRIORITY_PLAYBACK) IF_COP(, CPU))) == NULL)
 582     {
 583         log_text("Cannot create codec thread!",true);
 584         goto exit;
 585     }
 586
 587     /* Wait for codec thread to die */
 588     while (codec_playing)
 589     {
 590         rb->sleep(HZ);
 591         rb->snprintf(str,sizeof(str),"%d of %d",elapsed,(int)track.id3.length);
 592         log_text(str,false);
 593     }
 594     /* Save the current time before we spin up the disk to access the log */
 595     ticks = *rb->current_tick - starttick;
 596
 597     /* Be sure it is done */
 598     rb->thread_wait(codecthread_id);
 599
 600     log_text(str,true);
 601
 602     if (wavinfo.fd < 0)
 603     {
 604         /* Display benchmark information */
 605         rb->snprintf(str,sizeof(str),"Decode time - %d.%02ds",(int)ticks/100,(int)ticks%100);
 606         log_text(str,true);
 607
 608         duration = track.id3.length / 10;
 609         rb->snprintf(str,sizeof(str),"File duration - %d.%02ds",(int)duration/100,(int)duration%100);
 610         log_text(str,true);
 611
 612         if (ticks > 0)
 613             speed = duration * 10000 / ticks;
 614         else
 615             speed = 0;
 616
 617         rb->snprintf(str,sizeof(str),"%d.%02d%% realtime",(int)speed/100,(int)speed%100);
 618         log_text(str,true);
 619
 620 #ifndef SIMULATOR
 621         /* show effective clockrate in MHz needed for realtime decoding */
 622         if (speed > 0)
 623         {
 624             speed = CPUFREQ_MAX / speed;
 625             rb->snprintf(str,sizeof(str),"%d.%02dMHz needed for realtime",
 626             (int)speed/100,(int)speed%100);
 627             log_text(str,true);
 628         }
 629 #endif
 630     }
 631
 632     res = PLUGIN_OK;
 633
 634 exit:
 635     rb->backlight_on();
 636
 637     if (fd >= 0)
 638     {
 639         rb->close(fd);
 640     }
 641
 642     return res;
 643 }
 644
 645 /* plugin entry point */
 646 enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter)
 647 {
 648     uintptr_t* codec_stack_copy;
 649     int result, selection = 0;
 650     enum plugin_status res = PLUGIN_OK;
 651     int scandir;
 652     int i;
 653     struct dirent *entry;
 654     DIR* dir;
 655     char* ch;
 656     char dirpath[MAX_PATH];
 657     char filename[MAX_PATH];
 658
 659     rb = api;
 660
 661     if (parameter == NULL)
 662     {
 663         rb->splash(HZ*2, "No File");
 664         return PLUGIN_ERROR;
 665     }
 666
 667     codec_mallocbuf = rb->plugin_get_audio_buffer(&audiosize);
 668
 669 #ifdef SIMULATOR
 670     /* The simulator thread implementation doesn't have stack buffers */
 671     (void)i;
 672     codec_stack_size = 0;
 673 #else
 674     /* Borrow the codec thread's stack (in IRAM on most targets) */
 675     codec_stack = NULL;
 676     for (i = 0; i < MAXTHREADS; i++)
 677     {
 678         if (rb->strcmp(rb->threads[i].name,"codec")==0)
 679         {
 680             /* Wait to ensure the codec thread has blocked */
 681             while (rb->threads[i].state!=STATE_BLOCKED)
 682                 rb->yield();
 683
 684             codec_stack = rb->threads[i].stack;
 685             codec_stack_size = rb->threads[i].stack_size;
 686             break;
 687         }
 688     }
 689
 690     if (codec_stack == NULL)
 691     {
 692         rb->splash(HZ*2, "No codec thread!");
 693         return PLUGIN_ERROR;
 694     }
 695 #endif
 696
 697     codec_stack_copy = codec_mallocbuf + 512*1024;
 698     audiobuf = SKIPBYTES(codec_stack_copy, codec_stack_size);
 699     audiosize -= 512*1024 + codec_stack_size;
 700
 701 #ifndef SIMULATOR
 702     /* Backup the codec thread's stack */
 703     rb->memcpy(codec_stack_copy,codec_stack,codec_stack_size);
 704 #endif
 705
 706 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 707     rb->cpu_boost(true);
 708 #endif
 709     rb->lcd_clear_display();
 710     rb->lcd_update();
 711
 712     MENUITEM_STRINGLIST(
 713         menu, "test_codec", NULL,
 714         "Speed test",
 715         "Speed test folder",
 716         "Write WAV",
 717     );
 718
 719     rb->lcd_clear_display();
 720
 721     result=rb->do_menu(&menu,&selection, NULL, false);
 722
 723     scandir = 0;
 724
 725     if (result==0) {
 726         wavinfo.fd = -1;
 727         log_init(false);
 728     } else if (result==1) {
 729         wavinfo.fd = -1;
 730         scandir = 1;
 731
 732         /* Only create a log file when we are testing a folder */
 733         if (!log_init(true)) {
 734             rb->splash(HZ*2, "Cannot create logfile");
 735             res = PLUGIN_ERROR;
 736             goto exit;
 737         }
 738     } else if (result==2) {
 739         log_init(false);
 740         init_wav("/test.wav");
 741         if (wavinfo.fd < 0) {
 742             rb->splash(HZ*2, "Cannot create /test.wav");
 743             res = PLUGIN_ERROR;
 744             goto exit;
 745         }
 746     } else if (result == MENU_ATTACHED_USB) {
 747         res = PLUGIN_USB_CONNECTED;
 748         goto exit;
 749     } else if (result < 0) {
 750         res = PLUGIN_OK;
 751         goto exit;
 752     }
 753
 754     if (scandir) {
 755         /* Test all files in the same directory as the file selected by the
 756            user */
 757
 758         rb->strncpy(dirpath,parameter,sizeof(dirpath));
 759         ch = rb->strrchr(dirpath,'/');
 760         ch[1]=0;
 761
 762         DEBUGF("Scanning directory \"%s\"\n",dirpath);
 763         dir = rb->opendir(dirpath);
 764         if (dir) {
 765             entry = rb->readdir(dir);
 766             while (entry) {
 767                 if (!(entry->attribute & ATTR_DIRECTORY)) {
 768                     rb->snprintf(filename,sizeof(filename),"%s%s",dirpath,entry->d_name);
 769                     test_track(filename);
 770                     log_text("", true);
 771                 }
 772
 773                 /* Read next entry */
 774                 entry = rb->readdir(dir);
 775             }
 776
 777             rb->closedir(dir);
 778         }
 779     } else {
 780         /* Just test the file */
 781         res = test_track(parameter);
 782
 783         /* Close WAV file (if there was one) */
 784         if (wavinfo.fd >= 0) {
 785             close_wav();
 786             log_text("Wrote /test.wav",true);
 787         }
 788
 789         while (rb->button_get(true) != TESTCODEC_EXITBUTTON);
 790     }
 791
 792 exit:
 793     log_close();
 794
 795 #ifndef SIMULATOR
 796     /* Restore the codec thread's stack */
 797     rb->memcpy(codec_stack, codec_stack_copy, codec_stack_size);
 798 #endif
 799
 800 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 801     rb->cpu_boost(false);
 802 #endif
 803
 804     return res;
 805 }