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