Fix red in bootloaders
[maemo-rb.git] / apps / plugins / test_codec.c
bloba708ed7b076a2b1ef68ea4c03ce1c80b3f6fb662
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2007 Dave Chapman
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
21 #include "plugin.h"
23 PLUGIN_HEADER
25 /* All swcodec targets have BUTTON_SELECT apart from the H10 and M3 */
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 || CONFIG_KEYPAD == ONDAVX747_PAD
32 #define TESTCODEC_EXITBUTTON BUTTON_POWER
33 #else
34 #define TESTCODEC_EXITBUTTON BUTTON_SELECT
35 #endif
37 /* Log functions copied from test_disk.c */
38 static int line = 0;
39 static int max_line = 0;
40 static int log_fd = -1;
41 static char logfilename[MAX_PATH];
43 static bool log_init(bool use_logfile)
45 int h;
47 rb->lcd_getstringsize("A", NULL, &h);
48 max_line = LCD_HEIGHT / h;
49 line = 0;
50 rb->lcd_clear_display();
51 rb->lcd_update();
53 if (use_logfile) {
54 rb->create_numbered_filename(logfilename, "/", "test_codec_log_", ".txt",
55 2 IF_CNFN_NUM_(, NULL));
56 log_fd = rb->open(logfilename, O_RDWR|O_CREAT|O_TRUNC);
57 return log_fd >= 0;
60 return true;
63 static void log_text(char *text, bool advance)
65 rb->lcd_puts(0, line, text);
66 rb->lcd_update();
67 if (advance)
69 if (++line >= max_line)
70 line = 0;
71 if (log_fd >= 0)
72 rb->fdprintf(log_fd, "%s\n", text);
76 static void log_close(void)
78 if (log_fd >= 0)
79 rb->close(log_fd);
82 struct wavinfo_t
84 int fd;
85 int samplerate;
86 int channels;
87 int sampledepth;
88 int stereomode;
89 int totalsamples;
92 static void* audiobuf;
93 static void* codec_mallocbuf;
94 static size_t audiosize;
95 static char str[MAX_PATH];
97 /* Our local implementation of the codec API */
98 static struct codec_api ci;
100 struct test_track_info {
101 struct mp3entry id3; /* TAG metadata */
102 size_t filesize; /* File total length */
105 static struct test_track_info track;
106 static bool taginfo_ready = true;
108 static volatile unsigned int elapsed;
109 static volatile bool codec_playing;
110 static volatile long endtick;
111 struct wavinfo_t wavinfo;
113 static unsigned char wav_header[44] =
115 'R','I','F','F', // 0 - ChunkID
116 0,0,0,0, // 4 - ChunkSize (filesize-8)
117 'W','A','V','E', // 8 - Format
118 'f','m','t',' ', // 12 - SubChunkID
119 16,0,0,0, // 16 - SubChunk1ID // 16 for PCM
120 1,0, // 20 - AudioFormat (1=16-bit)
121 0,0, // 22 - NumChannels
122 0,0,0,0, // 24 - SampleRate in Hz
123 0,0,0,0, // 28 - Byte Rate (SampleRate*NumChannels*(BitsPerSample/8)
124 0,0, // 32 - BlockAlign (== NumChannels * BitsPerSample/8)
125 16,0, // 34 - BitsPerSample
126 'd','a','t','a', // 36 - Subchunk2ID
127 0,0,0,0 // 40 - Subchunk2Size
130 static inline void int2le32(unsigned char* buf, int32_t x)
132 buf[0] = (x & 0xff);
133 buf[1] = (x & 0xff00) >> 8;
134 buf[2] = (x & 0xff0000) >> 16;
135 buf[3] = (x & 0xff000000) >>24;
138 static inline void int2le24(unsigned char* buf, int32_t x)
140 buf[0] = (x & 0xff);
141 buf[1] = (x & 0xff00) >> 8;
142 buf[2] = (x & 0xff0000) >> 16;
145 static inline void int2le16(unsigned char* buf, int16_t x)
147 buf[0] = (x & 0xff);
148 buf[1] = (x & 0xff00) >> 8;
151 void init_wav(char* filename)
153 wavinfo.totalsamples = 0;
155 wavinfo.fd = rb->creat(filename);
157 if (wavinfo.fd >= 0)
159 /* Write WAV header - we go back and fill in the details at the end */
160 rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
165 void close_wav(void) {
166 int filesize = rb->filesize(wavinfo.fd);
167 int channels = (wavinfo.stereomode == STEREO_MONO) ? 1 : 2;
168 int bps = 16; /* TODO */
170 /* We assume 16-bit, Stereo */
172 rb->lseek(wavinfo.fd,0,SEEK_SET);
174 int2le32(wav_header+4, filesize-8); /* ChunkSize */
176 int2le16(wav_header+22, channels);
178 int2le32(wav_header+24, wavinfo.samplerate);
180 int2le32(wav_header+28, wavinfo.samplerate * channels * (bps / 8)); /* ByteRate */
182 int2le16(wav_header+32, channels * (bps / 8));
184 int2le32(wav_header+40, filesize - 44); /* Subchunk2Size */
186 rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
188 rb->close(wavinfo.fd);
191 /* Returns buffer to malloc array. Only codeclib should need this. */
192 static void* codec_get_buffer(size_t *size)
194 DEBUGF("codec_get_buffer(%d)\n",(int)size);
195 *size = CODEC_SIZE;
196 return codec_mallocbuf;
199 /* Null output */
200 static bool pcmbuf_insert_null(const void *ch1, const void *ch2, int count)
202 /* Always successful - just discard data */
203 (void)ch1;
204 (void)ch2;
205 (void)count;
207 /* Prevent idle poweroff */
208 rb->reset_poweroff_timer();
210 return true;
213 /* 64KB should be enough */
214 static unsigned char wavbuffer[64*1024];
216 static inline int32_t clip_sample(int32_t sample)
218 if ((int16_t)sample != sample)
219 sample = 0x7fff ^ (sample >> 31);
221 return sample;
225 /* WAV output */
226 static bool pcmbuf_insert_wav(const void *ch1, const void *ch2, int count)
228 const int16_t* data1_16;
229 const int16_t* data2_16;
230 const int32_t* data1_32;
231 const int32_t* data2_32;
232 unsigned char* p = wavbuffer;
233 const int scale = wavinfo.sampledepth - 15;
234 const int dc_bias = 1 << (scale - 1);
236 /* Prevent idle poweroff */
237 rb->reset_poweroff_timer();
239 if (wavinfo.sampledepth <= 16) {
240 data1_16 = ch1;
241 data2_16 = ch2;
243 switch(wavinfo.stereomode)
245 case STEREO_INTERLEAVED:
246 while (count--) {
247 int2le16(p,*data1_16++);
248 p += 2;
249 int2le16(p,*data1_16++);
250 p += 2;
252 break;
254 case STEREO_NONINTERLEAVED:
255 while (count--) {
256 int2le16(p,*data1_16++);
257 p += 2;
258 int2le16(p,*data2_16++);
259 p += 2;
262 break;
264 case STEREO_MONO:
265 while (count--) {
266 int2le16(p,*data1_16++);
267 p += 2;
269 break;
271 } else {
272 data1_32 = ch1;
273 data2_32 = ch2;
275 switch(wavinfo.stereomode)
277 case STEREO_INTERLEAVED:
278 while (count--) {
279 int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
280 p += 2;
281 int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
282 p += 2;
284 break;
286 case STEREO_NONINTERLEAVED:
287 while (count--) {
288 int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
289 p += 2;
290 int2le16(p, clip_sample((*data2_32++ + dc_bias) >> scale));
291 p += 2;
294 break;
296 case STEREO_MONO:
297 while (count--) {
298 int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
299 p += 2;
301 break;
305 wavinfo.totalsamples += count;
306 rb->write(wavinfo.fd, wavbuffer, p - wavbuffer);
308 return true;
312 /* Set song position in WPS (value in ms). */
313 static void set_elapsed(unsigned int value)
315 elapsed = value;
319 /* Read next <size> amount bytes from file buffer to <ptr>.
320 Will return number of bytes read or 0 if end of file. */
321 static size_t read_filebuf(void *ptr, size_t size)
323 if (ci.curpos > (off_t)track.filesize)
325 return 0;
326 } else {
327 /* TODO: Don't read beyond end of buffer */
328 rb->memcpy(ptr, audiobuf + ci.curpos, size);
329 ci.curpos += size;
330 return size;
335 /* Request pointer to file buffer which can be used to read
336 <realsize> amount of data. <reqsize> tells the buffer system
337 how much data it should try to allocate. If <realsize> is 0,
338 end of file is reached. */
339 static void* request_buffer(size_t *realsize, size_t reqsize)
341 *realsize = MIN(track.filesize-ci.curpos,reqsize);
343 return (audiobuf + ci.curpos);
347 /* Advance file buffer position by <amount> amount of bytes. */
348 static void advance_buffer(size_t amount)
350 ci.curpos += amount;
354 /* Advance file buffer to a pointer location inside file buffer. */
355 static void advance_buffer_loc(void *ptr)
357 ci.curpos = ptr - audiobuf;
361 /* Seek file buffer to position <newpos> beginning of file. */
362 static bool seek_buffer(size_t newpos)
364 ci.curpos = newpos;
365 return true;
369 /* Codec should call this function when it has done the seeking. */
370 static void seek_complete(void)
372 /* Do nothing */
375 /* Request file change from file buffer. Returns true is next
376 track is available and changed. If return value is false,
377 codec should exit immediately with PLUGIN_OK status. */
378 static bool request_next_track(void)
380 /* We are only decoding a single track */
381 return false;
385 /* Free the buffer area of the current codec after its loaded */
386 static void discard_codec(void)
388 /* ??? */
392 static void set_offset(size_t value)
394 /* ??? */
395 (void)value;
399 /* Configure different codec buffer parameters. */
400 static void configure(int setting, intptr_t value)
402 switch(setting)
404 case DSP_SWITCH_FREQUENCY:
405 case DSP_SET_FREQUENCY:
406 DEBUGF("samplerate=%d\n",(int)value);
407 wavinfo.samplerate = (int)value;
408 break;
410 case DSP_SET_SAMPLE_DEPTH:
411 DEBUGF("sampledepth = %d\n",(int)value);
412 wavinfo.sampledepth=(int)value;
413 break;
415 case DSP_SET_STEREO_MODE:
416 DEBUGF("Stereo mode = %d\n",(int)value);
417 wavinfo.stereomode=(int)value;
418 break;
423 static void init_ci(void)
425 /* --- Our "fake" implementations of the codec API functions. --- */
427 ci.codec_get_buffer = codec_get_buffer;
429 if (wavinfo.fd >= 0) {
430 ci.pcmbuf_insert = pcmbuf_insert_wav;
431 } else {
432 ci.pcmbuf_insert = pcmbuf_insert_null;
434 ci.set_elapsed = set_elapsed;
435 ci.read_filebuf = read_filebuf;
436 ci.request_buffer = request_buffer;
437 ci.advance_buffer = advance_buffer;
438 ci.advance_buffer_loc = advance_buffer_loc;
439 ci.seek_buffer = seek_buffer;
440 ci.seek_complete = seek_complete;
441 ci.request_next_track = request_next_track;
442 ci.discard_codec = discard_codec;
443 ci.set_offset = set_offset;
444 ci.configure = configure;
446 /* --- "Core" functions --- */
448 /* kernel/ system */
449 ci.sleep = rb->sleep;
450 ci.yield = rb->yield;
452 /* strings and memory */
453 ci.strcpy = rb->strcpy;
454 ci.strncpy = rb->strncpy;
455 ci.strlen = rb->strlen;
456 ci.strcmp = rb->strcmp;
457 ci.strcat = rb->strcat;
458 ci.memset = rb->memset;
459 ci.memcpy = rb->memcpy;
460 ci.memmove = rb->memmove;
461 ci.memcmp = rb->memcmp;
462 ci.memchr = rb->memchr;
463 ci.strcasestr = rb->strcasestr;
464 #if defined(DEBUG) || defined(SIMULATOR)
465 ci.debugf = rb->debugf;
466 #endif
467 #ifdef ROCKBOX_HAS_LOGF
468 ci.logf = rb->logf;
469 #endif
471 ci.qsort = rb->qsort;
472 ci.global_settings = rb->global_settings;
474 #ifdef RB_PROFILE
475 ci.profile_thread = rb->profile_thread;
476 ci.profstop = rb->profstop;
477 ci.profile_func_enter = rb->profile_func_enter;
478 ci.profile_func_exit = rb->profile_func_exit;
479 #endif
481 #if NUM_CORES > 1
482 ci.cpucache_invalidate = rb->cpucache_invalidate;
483 ci.cpucache_flush = rb->cpucache_flush;
484 #endif
486 #if NUM_CORES > 1
487 ci.create_thread = rb->create_thread;
488 ci.thread_thaw = rb->thread_thaw;
489 ci.thread_wait = rb->thread_wait;
490 ci.semaphore_init = rb->semaphore_init;
491 ci.semaphore_wait = rb->semaphore_wait;
492 ci.semaphore_release = rb->semaphore_release;
493 #endif
495 #ifdef CPU_ARM
496 ci.__div0 = rb->__div0;
497 #endif
500 static void codec_thread(void)
502 const char* codecname;
503 int res;
505 codecname = rb->get_codec_filename(track.id3.codectype);
507 /* Load the codec and start decoding. */
508 res = rb->codec_load_file(codecname,&ci);
510 /* Signal to the main thread that we are done */
511 endtick = *rb->current_tick;
512 codec_playing = false;
515 static enum plugin_status test_track(const char* filename)
517 size_t n;
518 int fd;
519 enum plugin_status res = PLUGIN_ERROR;
520 long starttick;
521 long ticks;
522 unsigned long speed;
523 unsigned long duration;
524 const char* ch;
526 /* Display filename (excluding any path)*/
527 ch = rb->strrchr(filename, '/');
528 if (ch==NULL)
529 ch = filename;
530 else
531 ch++;
533 rb->snprintf(str,sizeof(str),"%s",ch);
534 log_text(str,true);
536 log_text("Loading...",false);
538 fd = rb->open(filename,O_RDONLY);
539 if (fd < 0)
541 log_text("Cannot open file",true);
542 goto exit;
545 track.filesize = rb->filesize(fd);
547 /* Clear the id3 struct */
548 rb->memset(&track.id3, 0, sizeof(struct mp3entry));
550 if (!rb->get_metadata(&(track.id3), fd, filename))
552 log_text("Cannot read metadata",true);
553 goto exit;
556 if (track.filesize > audiosize)
558 log_text("File too large",true);
559 goto exit;
562 n = rb->read(fd, audiobuf, track.filesize);
564 if (n != track.filesize)
566 log_text("Read failed.",true);
567 goto exit;
570 /* Initialise the function pointers in the codec API */
571 init_ci();
573 /* Prepare the codec struct for playing the whole file */
574 ci.filesize = track.filesize;
575 ci.id3 = &track.id3;
576 ci.taginfo_ready = &taginfo_ready;
577 ci.curpos = 0;
578 ci.stop_codec = false;
579 ci.new_track = 0;
580 ci.seek_time = 0;
582 starttick = *rb->current_tick;
584 codec_playing = true;
586 rb->codec_thread_do_callback(codec_thread, NULL);
588 /* Wait for codec thread to die */
589 while (codec_playing)
591 rb->sleep(HZ);
592 rb->snprintf(str,sizeof(str),"%d of %d",elapsed,(int)track.id3.length);
593 log_text(str,false);
595 ticks = endtick - starttick;
597 /* Be sure it is done */
598 rb->codec_thread_do_callback(NULL, NULL);
600 log_text(str,true);
602 if (wavinfo.fd < 0)
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);
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);
612 if (ticks > 0)
613 speed = duration * 10000 / ticks;
614 else
615 speed = 0;
617 rb->snprintf(str,sizeof(str),"%d.%02d%% realtime",(int)speed/100,(int)speed%100);
618 log_text(str,true);
620 #ifndef SIMULATOR
621 /* show effective clockrate in MHz needed for realtime decoding */
622 if (speed > 0)
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);
629 #endif
632 res = PLUGIN_OK;
634 exit:
635 rb->backlight_on();
637 if (fd >= 0)
639 rb->close(fd);
642 return res;
645 /* plugin entry point */
646 enum plugin_status plugin_start(const void* parameter)
648 int result, selection = 0;
649 enum plugin_status res = PLUGIN_OK;
650 int scandir;
651 struct dirent *entry;
652 DIR* dir;
653 char* ch;
654 char dirpath[MAX_PATH];
655 char filename[MAX_PATH];
657 if (parameter == NULL)
659 rb->splash(HZ*2, "No File");
660 return PLUGIN_ERROR;
663 codec_mallocbuf = rb->plugin_get_audio_buffer(&audiosize);
664 audiobuf = SKIPBYTES(codec_mallocbuf, CODEC_SIZE);
665 audiosize -= CODEC_SIZE;
667 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
668 rb->cpu_boost(true);
669 #endif
670 rb->lcd_clear_display();
671 rb->lcd_update();
673 MENUITEM_STRINGLIST(
674 menu, "test_codec", NULL,
675 "Speed test",
676 "Speed test folder",
677 "Write WAV",
680 rb->lcd_clear_display();
682 result=rb->do_menu(&menu,&selection, NULL, false);
684 scandir = 0;
686 if (result==0) {
687 wavinfo.fd = -1;
688 log_init(false);
689 } else if (result==1) {
690 wavinfo.fd = -1;
691 scandir = 1;
693 /* Only create a log file when we are testing a folder */
694 if (!log_init(true)) {
695 rb->splash(HZ*2, "Cannot create logfile");
696 res = PLUGIN_ERROR;
697 goto exit;
699 } else if (result==2) {
700 log_init(false);
701 init_wav("/test.wav");
702 if (wavinfo.fd < 0) {
703 rb->splash(HZ*2, "Cannot create /test.wav");
704 res = PLUGIN_ERROR;
705 goto exit;
707 } else if (result == MENU_ATTACHED_USB) {
708 res = PLUGIN_USB_CONNECTED;
709 goto exit;
710 } else if (result < 0) {
711 res = PLUGIN_OK;
712 goto exit;
715 if (scandir) {
716 /* Test all files in the same directory as the file selected by the
717 user */
719 rb->strncpy(dirpath,parameter,sizeof(dirpath));
720 ch = rb->strrchr(dirpath,'/');
721 ch[1]=0;
723 DEBUGF("Scanning directory \"%s\"\n",dirpath);
724 dir = rb->opendir(dirpath);
725 if (dir) {
726 entry = rb->readdir(dir);
727 while (entry) {
728 if (!(entry->attribute & ATTR_DIRECTORY)) {
729 rb->snprintf(filename,sizeof(filename),"%s%s",dirpath,entry->d_name);
730 test_track(filename);
731 log_text("", true);
734 /* Read next entry */
735 entry = rb->readdir(dir);
738 rb->closedir(dir);
740 } else {
741 /* Just test the file */
742 res = test_track(parameter);
744 /* Close WAV file (if there was one) */
745 if (wavinfo.fd >= 0) {
746 close_wav();
747 log_text("Wrote /test.wav",true);
750 while (rb->button_get(true) != TESTCODEC_EXITBUTTON);
753 exit:
754 log_close();
756 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
757 rb->cpu_boost(false);
758 #endif
760 return res;