?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use lib display text to display help messages (FS#10099).
[kugel-rb.git] / apps / plugins / test_codec.c
bloba708ed7b076a2b1ef68ea4c03ce1c80b3f6fb662
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 || CONFIG_KEYPAD == ONDAVX747_PAD
32 #define TESTCODEC_EXITBUTTON BUTTON_POWER
33 #else
34 #define TESTCODEC_EXITBUTTON BUTTON_SELECT
35 #endif
36
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];
42
43 static bool log_init(bool use_logfile)
44 {
45 int h;
46
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();
52
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;
58 }
59
60 return true;
61 }
62
63 static void log_text(char *text, bool advance)
64 {
65 rb->lcd_puts(0, line, text);
66 rb->lcd_update();
67 if (advance)
68 {
69 if (++line >= max_line)
70 line = 0;
71 if (log_fd >= 0)
72 rb->fdprintf(log_fd, "%s\n", text);
73 }
74 }
75
76 static void log_close(void)
77 {
78 if (log_fd >= 0)
79 rb->close(log_fd);
80 }
81
82 struct wavinfo_t
83 {
84 int fd;
85 int samplerate;
86 int channels;
87 int sampledepth;
88 int stereomode;
89 int totalsamples;
90 };
91
92 static void* audiobuf;
93 static void* codec_mallocbuf;
94 static size_t audiosize;
95 static char str[MAX_PATH];
96
97 /* Our local implementation of the codec API */
98 static struct codec_api ci;
99
100 struct test_track_info {
101 struct mp3entry id3; /* TAG metadata */
102 size_t filesize; /* File total length */
103 };
104
105 static struct test_track_info track;
106 static bool taginfo_ready = true;
107
108 static volatile unsigned int elapsed;
109 static volatile bool codec_playing;
110 static volatile long endtick;
111 struct wavinfo_t wavinfo;
112
113 static unsigned char wav_header[44] =
114 {
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
128 };
129
130 static inline void int2le32(unsigned char* buf, int32_t x)
131 {
132 buf[0] = (x & 0xff);
133 buf[1] = (x & 0xff00) >> 8;
134 buf[2] = (x & 0xff0000) >> 16;
135 buf[3] = (x & 0xff000000) >>24;
136 }
137
138 static inline void int2le24(unsigned char* buf, int32_t x)
139 {
140 buf[0] = (x & 0xff);
141 buf[1] = (x & 0xff00) >> 8;
142 buf[2] = (x & 0xff0000) >> 16;
143 }
144
145 static inline void int2le16(unsigned char* buf, int16_t x)
146 {
147 buf[0] = (x & 0xff);
148 buf[1] = (x & 0xff00) >> 8;
149 }
150
151 void init_wav(char* filename)
152 {
153 wavinfo.totalsamples = 0;
154
155 wavinfo.fd = rb->creat(filename);
156
157 if (wavinfo.fd >= 0)
158 {
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));
161 }
162 }
163
164
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 */
169
170 /* We assume 16-bit, Stereo */
171
172 rb->lseek(wavinfo.fd,0,SEEK_SET);
173
174 int2le32(wav_header+4, filesize-8); /* ChunkSize */
175
176 int2le16(wav_header+22, channels);
177
178 int2le32(wav_header+24, wavinfo.samplerate);
179
180 int2le32(wav_header+28, wavinfo.samplerate * channels * (bps / 8)); /* ByteRate */
181
182 int2le16(wav_header+32, channels * (bps / 8));
183
184 int2le32(wav_header+40, filesize - 44); /* Subchunk2Size */
185
186 rb->write(wavinfo.fd, wav_header, sizeof(wav_header));
187
188 rb->close(wavinfo.fd);
189 }
190
191 /* Returns buffer to malloc array. Only codeclib should need this. */
192 static void* codec_get_buffer(size_t *size)
193 {
194 DEBUGF("codec_get_buffer(%d)\n",(int)size);
195 *size = CODEC_SIZE;
196 return codec_mallocbuf;
197 }
198
199 /* Null output */
200 static bool pcmbuf_insert_null(const void *ch1, const void *ch2, int count)
201 {
202 /* Always successful - just discard data */
203 (void)ch1;
204 (void)ch2;
205 (void)count;
206
207 /* Prevent idle poweroff */
208 rb->reset_poweroff_timer();
209
210 return true;
211 }
212
213 /* 64KB should be enough */
214 static unsigned char wavbuffer[64*1024];
215
216 static inline int32_t clip_sample(int32_t sample)
217 {
218 if ((int16_t)sample != sample)
219 sample = 0x7fff ^ (sample >> 31);
220
221 return sample;
222 }
223
224
225 /* WAV output */
226 static bool pcmbuf_insert_wav(const void *ch1, const void *ch2, int count)
227 {
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);
235
236 /* Prevent idle poweroff */
237 rb->reset_poweroff_timer();
238
239 if (wavinfo.sampledepth <= 16) {
240 data1_16 = ch1;
241 data2_16 = ch2;
242
243 switch(wavinfo.stereomode)
244 {
245 case STEREO_INTERLEAVED:
246 while (count--) {
247 int2le16(p,*data1_16++);
248 p += 2;
249 int2le16(p,*data1_16++);
250 p += 2;
251 }
252 break;
253
254 case STEREO_NONINTERLEAVED:
255 while (count--) {
256 int2le16(p,*data1_16++);
257 p += 2;
258 int2le16(p,*data2_16++);
259 p += 2;
260 }
261
262 break;
263
264 case STEREO_MONO:
265 while (count--) {
266 int2le16(p,*data1_16++);
267 p += 2;
268 }
269 break;
270 }
271 } else {
272 data1_32 = ch1;
273 data2_32 = ch2;
274
275 switch(wavinfo.stereomode)
276 {
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;
283 }
284 break;
285
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;
292 }
293
294 break;
295
296 case STEREO_MONO:
297 while (count--) {
298 int2le16(p, clip_sample((*data1_32++ + dc_bias) >> scale));
299 p += 2;
300 }
301 break;
302 }
303 }
304
305 wavinfo.totalsamples += count;
306 rb->write(wavinfo.fd, wavbuffer, p - wavbuffer);
307
308 return true;
309 }
310
311
312 /* Set song position in WPS (value in ms). */
313 static void set_elapsed(unsigned int value)
314 {
315 elapsed = value;
316 }
317
318
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)
322 {
323 if (ci.curpos > (off_t)track.filesize)
324 {
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;
331 }
332 }
333
334
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)
340 {
341 *realsize = MIN(track.filesize-ci.curpos,reqsize);
342
343 return (audiobuf + ci.curpos);
344 }
345
346
347 /* Advance file buffer position by <amount> amount of bytes. */
348 static void advance_buffer(size_t amount)
349 {
350 ci.curpos += amount;
351 }
352
353
354 /* Advance file buffer to a pointer location inside file buffer. */
355 static void advance_buffer_loc(void *ptr)
356 {
357 ci.curpos = ptr - audiobuf;
358 }
359
360
361 /* Seek file buffer to position <newpos> beginning of file. */
362 static bool seek_buffer(size_t newpos)
363 {
364 ci.curpos = newpos;
365 return true;
366 }
367
368
369 /* Codec should call this function when it has done the seeking. */
370 static void seek_complete(void)
371 {
372 /* Do nothing */
373 }
374
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)
379 {
380 /* We are only decoding a single track */
381 return false;
382 }
383
384
385 /* Free the buffer area of the current codec after its loaded */
386 static void discard_codec(void)
387 {
388 /* ??? */
389 }
390
391
392 static void set_offset(size_t value)
393 {
394 /* ??? */
395 (void)value;
396 }
397
398
399 /* Configure different codec buffer parameters. */
400 static void configure(int setting, intptr_t value)
401 {
402 switch(setting)
403 {
404 case DSP_SWITCH_FREQUENCY:
405 case DSP_SET_FREQUENCY:
406 DEBUGF("samplerate=%d\n",(int)value);
407 wavinfo.samplerate = (int)value;
408 break;
409
410 case DSP_SET_SAMPLE_DEPTH:
411 DEBUGF("sampledepth = %d\n",(int)value);
412 wavinfo.sampledepth=(int)value;
413 break;
414
415 case DSP_SET_STEREO_MODE:
416 DEBUGF("Stereo mode = %d\n",(int)value);
417 wavinfo.stereomode=(int)value;
418 break;
419 }
420
421 }
422
423 static void init_ci(void)
424 {
425 /* --- Our "fake" implementations of the codec API functions. --- */
426
427 ci.codec_get_buffer = codec_get_buffer;
428
429 if (wavinfo.fd >= 0) {
430 ci.pcmbuf_insert = pcmbuf_insert_wav;
431 } else {
432 ci.pcmbuf_insert = pcmbuf_insert_null;
433 }
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;
445
446 /* --- "Core" functions --- */
447
448 /* kernel/ system */
449 ci.sleep = rb->sleep;
450 ci.yield = rb->yield;
451
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
470
471 ci.qsort = rb->qsort;
472 ci.global_settings = rb->global_settings;
473
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
480
481 #if NUM_CORES > 1
482 ci.cpucache_invalidate = rb->cpucache_invalidate;
483 ci.cpucache_flush = rb->cpucache_flush;
484 #endif
485
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
494
495 #ifdef CPU_ARM
496 ci.__div0 = rb->__div0;
497 #endif
498 }
499
500 static void codec_thread(void)
501 {
502 const char* codecname;
503 int res;
504
505 codecname = rb->get_codec_filename(track.id3.codectype);
506
507 /* Load the codec and start decoding. */
508 res = rb->codec_load_file(codecname,&ci);
509
510 /* Signal to the main thread that we are done */
511 endtick = *rb->current_tick;
512 codec_playing = false;
513 }
514
515 static enum plugin_status test_track(const char* filename)
516 {
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;
525
526 /* Display filename (excluding any path)*/
527 ch = rb->strrchr(filename, '/');
528 if (ch==NULL)
529 ch = filename;
530 else
531 ch++;
532
533 rb->snprintf(str,sizeof(str),"%s",ch);
534 log_text(str,true);
535
536 log_text("Loading...",false);
537
538 fd = rb->open(filename,O_RDONLY);
539 if (fd < 0)
540 {
541 log_text("Cannot open file",true);
542 goto exit;
543 }
544
545 track.filesize = rb->filesize(fd);
546
547 /* Clear the id3 struct */
548 rb->memset(&track.id3, 0, sizeof(struct mp3entry));
549
550 if (!rb->get_metadata(&(track.id3), fd, filename))
551 {
552 log_text("Cannot read metadata",true);
553 goto exit;
554 }
555
556 if (track.filesize > audiosize)
557 {
558 log_text("File too large",true);
559 goto exit;
560 }
561
562 n = rb->read(fd, audiobuf, track.filesize);
563
564 if (n != track.filesize)
565 {
566 log_text("Read failed.",true);
567 goto exit;
568 }
569
570 /* Initialise the function pointers in the codec API */
571 init_ci();
572
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;
581
582 starttick = *rb->current_tick;
583
584 codec_playing = true;
585
586 rb->codec_thread_do_callback(codec_thread, NULL);
587
588 /* Wait for codec thread to die */
589 while (codec_playing)
590 {
591 rb->sleep(HZ);
592 rb->snprintf(str,sizeof(str),"%d of %d",elapsed,(int)track.id3.length);
593 log_text(str,false);
594 }
595 ticks = endtick - starttick;
596
597 /* Be sure it is done */
598 rb->codec_thread_do_callback(NULL, NULL);
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 void* parameter)
647 {
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];
656
657 if (parameter == NULL)
658 {
659 rb->splash(HZ*2, "No File");
660 return PLUGIN_ERROR;
661 }
662
663 codec_mallocbuf = rb->plugin_get_audio_buffer(&audiosize);
664 audiobuf = SKIPBYTES(codec_mallocbuf, CODEC_SIZE);
665 audiosize -= CODEC_SIZE;
666
667 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
668 rb->cpu_boost(true);
669 #endif
670 rb->lcd_clear_display();
671 rb->lcd_update();
672
673 MENUITEM_STRINGLIST(
674 menu, "test_codec", NULL,
675 "Speed test",
676 "Speed test folder",
677 "Write WAV",
678 );
679
680 rb->lcd_clear_display();
681
682 result=rb->do_menu(&menu,&selection, NULL, false);
683
684 scandir = 0;
685
686 if (result==0) {
687 wavinfo.fd = -1;
688 log_init(false);
689 } else if (result==1) {
690 wavinfo.fd = -1;
691 scandir = 1;
692
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;
698 }
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;
706 }
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;
713 }
714
715 if (scandir) {
716 /* Test all files in the same directory as the file selected by the
717 user */
718
719 rb->strncpy(dirpath,parameter,sizeof(dirpath));
720 ch = rb->strrchr(dirpath,'/');
721 ch[1]=0;
722
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);
732 }
733
734 /* Read next entry */
735 entry = rb->readdir(dir);
736 }
737
738 rb->closedir(dir);
739 }
740 } else {
741 /* Just test the file */
742 res = test_track(parameter);
743
744 /* Close WAV file (if there was one) */
745 if (wavinfo.fd >= 0) {
746 close_wav();
747 log_text("Wrote /test.wav",true);
748 }
749
750 while (rb->button_get(true) != TESTCODEC_EXITBUTTON);
751 }
752
753 exit:
754 log_close();
755
756 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
757 rb->cpu_boost(false);
758 #endif
759
760 return res;
761 }
My public Rockbox git repo