1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2004 Jörg Hohensohn
12 * This module collects the Talkbox and voice UI functions.
13 * (Talkbox reads directory names from mp3 clips called thumbnails,
14 * the voice UI lets menus and screens "talk" from a voicefile in memory.
16 * All files in this archive are subject to the GNU General Public License.
17 * See the file COPYING in the source tree root for full license agreement.
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
22 ****************************************************************************/
31 #include "mp3_playback.h"
38 #if CONFIG_CODEC == SWCODEC
44 /* Memory layout varies between targets because the
45 Archos (MASCODEC) devices cannot mix voice and audio playback
47 MASCODEC | MASCODEC | SWCODEC
48 (playing) | (stopped) |
49 audiobuf-----------+-----------+-----------
50 audio | voice | thumbnail
51 |-----------|----------- filebuf
55 audiobufend----------+-----------+-----------
57 SWCODEC allocates dedicated buffers, MASCODEC reuses audiobuf. */
60 /***************** Constants *****************/
62 #define QUEUE_SIZE 64 /* must be a power of two */
63 #define QUEUE_MASK (QUEUE_SIZE-1)
64 const char* const dir_thumbnail_name
= "_dirname.talk";
65 const char* const file_thumbnail_ext
= ".talk";
67 /***************** Functional Macros *****************/
69 #define QUEUE_LEVEL ((queue_write - queue_read) & QUEUE_MASK)
71 #define LOADED_MASK 0x80000000 /* MSB */
73 #if CONFIG_CODEC == SWCODEC
74 #define MAX_THUMBNAIL_BUFSIZE 32768
78 /***************** Data types *****************/
80 struct clip_entry
/* one entry of the index table */
82 int offset
; /* offset from start of voicefile file */
83 int size
; /* size of the clip */
86 struct voicefile
/* file format of our voice file */
88 int version
; /* version of the voicefile */
89 int table
; /* offset to index table, (=header size) */
90 int id1_max
; /* number of "normal" clips contained in above index */
91 int id2_max
; /* number of "voice only" clips contained in above index */
92 struct clip_entry index
[]; /* followed by the index tables */
93 /* and finally the bitswapped mp3 clips, not visible here */
96 struct queue_entry
/* one entry of the internal queue */
103 /***************** Globals *****************/
105 static unsigned char* p_thumbnail
; /* buffer for thumbnail */
106 static long size_for_thumbnail
; /* leftover buffer size for it */
107 static struct voicefile
* p_voicefile
; /* loaded voicefile */
108 static bool has_voicefile
; /* a voicefile file is present */
109 static struct queue_entry queue
[QUEUE_SIZE
]; /* queue of scheduled clips */
110 static int queue_write
; /* write index of queue, by application */
111 static int queue_read
; /* read index of queue, by ISR context */
112 static int sent
; /* how many bytes handed over to playback, owned by ISR */
113 static unsigned char curr_hd
[3]; /* current frame header, for re-sync */
114 static int filehandle
= -1; /* global, so the MMC variant can keep the file open */
115 static unsigned char* p_silence
; /* VOICE_PAUSE clip, used for termination */
116 static long silence_len
; /* length of the VOICE_PAUSE clip */
117 static unsigned char* p_lastclip
; /* address of latest clip, for silence add */
118 static unsigned long voicefile_size
= 0; /* size of the loaded voice file */
119 static unsigned char last_lang
[MAX_FILENAME
+1]; /* name of last used lang file (in talk_init) */
120 static bool talk_initialized
; /* true if talk_init has been called */
122 /***************** Private prototypes *****************/
124 static void load_voicefile(void);
125 static void mp3_callback(unsigned char** start
, int* size
);
126 static int shutup(void);
127 static int queue_clip(unsigned char* buf
, long size
, bool enqueue
);
128 static int open_voicefile(void);
129 static unsigned char* get_clip(long id
, long* p_size
);
132 /***************** Private implementation *****************/
134 static int open_voicefile(void)
137 char* p_lang
= "english"; /* default */
139 if ( global_settings
.lang_file
[0] &&
140 global_settings
.lang_file
[0] != 0xff )
141 { /* try to open the voice file of the selected language */
142 p_lang
= (char *)global_settings
.lang_file
;
145 snprintf(buf
, sizeof(buf
), ROCKBOX_DIR LANG_DIR
"/%s.voice", p_lang
);
147 return open(buf
, O_RDONLY
);
151 /* load the voice file into the mp3 buffer */
152 static void load_voicefile(void)
157 #if CONFIG_CODEC == SWCODEC
159 unsigned char *buf
, temp
;
162 filehandle
= open_voicefile();
163 if (filehandle
< 0) /* failed to open */
166 file_size
= filesize(filehandle
);
167 if (file_size
> audiobufend
- audiobuf
) /* won't fit? */
170 #ifdef HAVE_MMC /* load only the header for now */
171 load_size
= offsetof(struct voicefile
, index
);
172 #else /* load the full file */
173 load_size
= file_size
;
176 got_size
= read(filehandle
, audiobuf
, load_size
);
177 if (got_size
!= load_size
/* failure */)
180 #ifdef ROCKBOX_LITTLE_ENDIAN
181 logf("Byte swapping voice file");
182 p_voicefile
= (struct voicefile
*)audiobuf
;
183 p_voicefile
->version
= swap32(p_voicefile
->version
);
184 p_voicefile
->table
= swap32(p_voicefile
->table
);
185 p_voicefile
->id1_max
= swap32(p_voicefile
->id1_max
);
186 p_voicefile
->id2_max
= swap32(p_voicefile
->id2_max
);
190 if (((struct voicefile
*)audiobuf
)->table
/* format check */
191 == offsetof(struct voicefile
, index
))
193 p_voicefile
= (struct voicefile
*)audiobuf
;
195 #if CONFIG_CODEC != SWCODEC
196 /* MASCODEC: now use audiobuf for voice then thumbnail */
197 p_thumbnail
= audiobuf
+ file_size
;
198 p_thumbnail
+= (long)p_thumbnail
% 2; /* 16-bit align */
199 size_for_thumbnail
= audiobufend
- p_thumbnail
;
205 #ifdef ROCKBOX_LITTLE_ENDIAN
206 for (i
= 0; i
< p_voicefile
->id1_max
+ p_voicefile
->id2_max
; i
++)
208 struct clip_entry
*ce
;
209 ce
= &p_voicefile
->index
[i
];
210 ce
->offset
= swap32(ce
->offset
);
211 ce
->size
= swap32(ce
->size
);
215 /* Do a bitswap as necessary. */
216 #if CONFIG_CODEC == SWCODEC
217 logf("Bitswapping voice file.");
219 buf
= (unsigned char *)(&p_voicefile
->index
) +
220 (p_voicefile
->id1_max
+ p_voicefile
->id2_max
) * sizeof(struct clip_entry
);
221 length
= file_size
- (buf
- (unsigned char *) p_voicefile
);
223 for (i
= 0; i
< length
; i
++)
226 temp
= ((temp
>> 4) & 0x0f) | ((temp
& 0x0f) << 4);
227 temp
= ((temp
>> 2) & 0x33) | ((temp
& 0x33) << 2);
228 buf
[i
] = ((temp
>> 1) & 0x55) | ((temp
& 0x55) << 1);
235 /* load the index table, now that we know its size from the header */
236 load_size
= (p_voicefile
->id1_max
+ p_voicefile
->id2_max
)
237 * sizeof(struct clip_entry
);
238 got_size
= read(filehandle
,
239 (unsigned char *) p_voicefile
+ offsetof(struct voicefile
, index
), load_size
);
240 if (got_size
!= load_size
) /* read error */
243 close(filehandle
); /* only the MMC variant leaves it open */
247 /* make sure to have the silence clip, if available */
248 p_silence
= get_clip(VOICE_PAUSE
, &silence_len
);
254 has_voicefile
= false; /* don't try again */
264 /* called in ISR context if mp3 data got consumed */
265 static void mp3_callback(unsigned char** start
, int* size
)
267 queue
[queue_read
].len
-= sent
; /* we completed this */
268 queue
[queue_read
].buf
+= sent
;
270 if (queue
[queue_read
].len
> 0) /* current clip not finished? */
271 { /* feed the next 64K-1 chunk */
272 #if CONFIG_CODEC != SWCODEC
273 sent
= MIN(queue
[queue_read
].len
, 0xFFFF);
275 sent
= queue
[queue_read
].len
;
277 *start
= queue
[queue_read
].buf
;
281 else if (sent
> 0) /* go to next entry */
283 queue_read
= (queue_read
+ 1) & QUEUE_MASK
;
288 if (QUEUE_LEVEL
) /* queue is not empty? */
289 { /* start next clip */
290 #if CONFIG_CODEC != SWCODEC
291 sent
= MIN(queue
[queue_read
].len
, 0xFFFF);
293 sent
= queue
[queue_read
].len
;
295 *start
= p_lastclip
= queue
[queue_read
].buf
;
297 curr_hd
[0] = p_lastclip
[1];
298 curr_hd
[1] = p_lastclip
[2];
299 curr_hd
[2] = p_lastclip
[3];
301 else if (p_silence
!= NULL
/* silence clip available */
302 && p_lastclip
!= p_silence
/* previous clip wasn't silence */
303 && p_lastclip
!= p_thumbnail
) /* ..or thumbnail */
304 { /* add silence clip when queue runs empty playing a voice clip */
305 queue
[queue_write
].buf
= p_silence
;
306 queue
[queue_write
].len
= silence_len
;
307 queue_write
= (queue_write
+ 1) & QUEUE_MASK
;
313 *size
= 0; /* end of data */
314 mp3_play_stop(); /* fixme: should be done by caller */
318 /* stop the playback and the pending clips, but at frame boundary */
319 static int shutup(void)
322 unsigned char* search
;
325 if (QUEUE_LEVEL
== 0) /* has ended anyway */
329 #if CONFIG_CPU == SH7034
330 CHCR3
&= ~0x0001; /* disable the DMA (and therefore the interrupt also) */
332 /* search next frame boundary and continue up to there */
333 pos
= search
= mp3_get_pos();
334 end
= queue
[queue_read
].buf
+ queue
[queue_read
].len
;
336 if (pos
>= queue
[queue_read
].buf
337 && pos
<= end
) /* really our clip? */
338 { /* (for strange reasons this isn't nesessarily the case) */
339 /* find the next frame boundary */
340 while (search
< end
) /* search the remaining data */
342 if (*search
++ != 0xFF) /* quick search for frame sync byte */
343 continue; /* (this does the majority of the job) */
345 /* look at the (bitswapped) rest of header candidate */
346 if (search
[0] == curr_hd
[0] /* do the quicker checks first */
347 && search
[2] == curr_hd
[2]
348 && (search
[1] & 0x30) == (curr_hd
[1] & 0x30)) /* sample rate */
350 search
--; /* back to the sync byte */
351 break; /* From looking at it, this is our header. */
356 { /* play old data until the frame end, to keep the MAS in sync */
359 queue_write
= (queue_read
+ 1) & QUEUE_MASK
; /* will be empty after next callback */
360 queue
[queue_read
].len
= sent
; /* current one ends after this */
362 #if CONFIG_CPU == SH7034
363 DTCR3
= sent
; /* let the DMA finish this frame */
364 CHCR3
|= 0x0001; /* re-enable DMA */
370 /* nothing to do, was frame boundary or not our clip */
372 queue_write
= queue_read
= 0; /* reset the queue */
378 /* schedule a clip, at the end or discard the existing queue */
379 static int queue_clip(unsigned char* buf
, long size
, bool enqueue
)
384 shutup(); /* cut off all the pending stuff */
387 return 0; /* safety check */
388 #if CONFIG_CPU == SH7034
389 /* disable the DMA temporarily, to be safe of race condition */
392 queue_level
= QUEUE_LEVEL
; /* check old level */
394 if (queue_level
< QUEUE_SIZE
- 1) /* space left? */
396 queue
[queue_write
].buf
= buf
; /* populate an entry */
397 queue
[queue_write
].len
= size
;
398 queue_write
= (queue_write
+ 1) & QUEUE_MASK
;
401 if (queue_level
== 0)
402 { /* queue was empty, we have to do the initial start */
404 #if CONFIG_CODEC != SWCODEC
405 sent
= MIN(size
, 0xFFFF); /* DMA can do no more */
409 mp3_play_data(buf
, sent
, mp3_callback
);
413 mp3_play_pause(true); /* kickoff audio */
417 #if CONFIG_CPU == SH7034
418 CHCR3
|= 0x0001; /* re-enable DMA */
425 /* fetch a clip from the voice file */
426 static unsigned char* get_clip(long id
, long* p_size
)
429 unsigned char* clipbuf
;
431 if (id
> VOICEONLY_DELIMITER
)
432 { /* voice-only entries use the second part of the table */
433 id
-= VOICEONLY_DELIMITER
+ 1;
434 if (id
>= p_voicefile
->id2_max
)
435 return NULL
; /* must be newer than we have */
436 id
+= p_voicefile
->id1_max
; /* table 2 is behind table 1 */
439 { /* normal use of the first table */
440 if (id
>= p_voicefile
->id1_max
)
441 return NULL
; /* must be newer than we have */
444 clipsize
= p_voicefile
->index
[id
].size
;
445 if (clipsize
== 0) /* clip not included in voicefile */
447 clipbuf
= (unsigned char *) p_voicefile
+ p_voicefile
->index
[id
].offset
;
449 #ifdef HAVE_MMC /* dynamic loading, on demand */
450 if (!(clipsize
& LOADED_MASK
))
451 { /* clip used for the first time, needs loading */
452 lseek(filehandle
, p_voicefile
->index
[id
].offset
, SEEK_SET
);
453 if (read(filehandle
, clipbuf
, clipsize
) != clipsize
)
454 return NULL
; /* read error */
456 p_voicefile
->index
[id
].size
|= LOADED_MASK
; /* mark as loaded */
459 { /* clip is in memory already */
460 clipsize
&= ~LOADED_MASK
; /* without the extra bit gives true size */
469 /* common code for talk_init() and talk_buffer_steal() */
470 static void reset_state(void)
472 queue_write
= queue_read
= 0; /* reset the queue */
473 p_voicefile
= NULL
; /* indicate no voicefile (trashed) */
474 #if CONFIG_CODEC == SWCODEC
475 /* Allocate a dedicated thumbnail buffer */
476 size_for_thumbnail
= audiobufend
- audiobuf
;
477 if (size_for_thumbnail
> MAX_THUMBNAIL_BUFSIZE
)
478 size_for_thumbnail
= MAX_THUMBNAIL_BUFSIZE
;
479 p_thumbnail
= buffer_alloc(size_for_thumbnail
);
481 /* Just use the audiobuf, without allocating anything */
482 p_thumbnail
= audiobuf
;
483 size_for_thumbnail
= audiobufend
- audiobuf
;
485 p_silence
= NULL
; /* pause clip not accessible */
488 /***************** Public implementation *****************/
492 if (talk_initialized
&& !strcasecmp(last_lang
, global_settings
.lang_file
))
494 /* not a new file, nothing to do */
499 if (filehandle
>= 0) /* MMC: An old voice file might still be open */
506 talk_initialized
= true;
507 strncpy((char *) last_lang
, (char *)global_settings
.lang_file
,
510 #if CONFIG_CODEC == SWCODEC
513 reset_state(); /* use this for most of our inits */
515 filehandle
= open_voicefile();
516 has_voicefile
= (filehandle
>= 0); /* test if we can open it */
521 voicefile_size
= filesize(filehandle
);
522 #if CONFIG_CODEC == SWCODEC
525 close(filehandle
); /* close again, this was just to detect presence */
531 /* return if a voice codec is required or not */
532 bool talk_voice_required(void)
534 return (voicefile_size
!= 0) /* Voice file is available */
535 || (global_settings
.talk_dir
== 3) /* Thumbnail clips are required */
536 || (global_settings
.talk_file
== 3);
539 /* return size of voice file */
540 int talk_get_bufsize(void)
542 return voicefile_size
;
545 /* somebody else claims the mp3 buffer, e.g. for regular play/record */
546 int talk_buffer_steal(void)
550 if (filehandle
>= 0) /* only relevant for MMC */
561 /* play a voice ID from voicefile */
562 int talk_id(long id
, bool enqueue
)
565 unsigned char* clipbuf
;
568 #if CONFIG_CODEC != SWCODEC
569 if (audio_status()) /* busy, buffer in use */
573 if (p_voicefile
== NULL
&& has_voicefile
)
574 load_voicefile(); /* reload needed */
576 if (p_voicefile
== NULL
) /* still no voices? */
579 if (id
== -1) /* -1 is an indication for silence */
582 /* check if this is a special ID, with a value */
583 unit
= ((unsigned long)id
) >> UNIT_SHIFT
;
585 { /* sign-extend the value */
586 id
= (unsigned long)id
<< (32-UNIT_SHIFT
);
587 id
>>= (32-UNIT_SHIFT
);
588 talk_value(id
, unit
, enqueue
); /* speak it */
589 return 0; /* and stop, end of special case */
592 clipbuf
= get_clip(id
, &clipsize
);
594 return -1; /* not present */
596 queue_clip(clipbuf
, clipsize
, enqueue
);
602 /* play a thumbnail from file */
603 int talk_file(const char* filename
, bool enqueue
)
607 struct mp3entry info
;
609 #if CONFIG_CODEC != SWCODEC
610 if (audio_status()) /* busy, buffer in use */
614 if (p_thumbnail
== NULL
|| size_for_thumbnail
<= 0)
617 if(mp3info(&info
, filename
, false)) /* use this to find real start */
619 return 0; /* failed to open, or invalid */
622 fd
= open(filename
, O_RDONLY
);
623 if (fd
< 0) /* failed to open */
628 lseek(fd
, info
.first_frame_offset
, SEEK_SET
); /* behind ID data */
630 size
= read(fd
, p_thumbnail
, size_for_thumbnail
);
633 /* ToDo: find audio, skip ID headers and trailers */
635 if (size
!= 0 && size
!= size_for_thumbnail
) /* Don't play missing or truncated clips */
637 #if CONFIG_CODEC != SWCODEC
638 bitswap(p_thumbnail
, size
);
640 queue_clip(p_thumbnail
, size
, enqueue
);
647 /* say a numeric value, this word ordering works for english,
648 but not necessarily for other languages (e.g. german) */
649 int talk_number(long n
, bool enqueue
)
651 int level
= 2; /* mille count */
652 long mil
= 1000000000; /* highest possible "-illion" */
654 #if CONFIG_CODEC != SWCODEC
655 if (audio_status()) /* busy, buffer in use */
660 shutup(); /* cut off all the pending stuff */
664 talk_id(VOICE_ZERO
, true);
670 talk_id(VOICE_MINUS
, true);
676 int segment
= n
/ mil
; /* extract in groups of 3 digits */
677 n
-= segment
* mil
; /* remove the used digits from number */
678 mil
/= 1000; /* digit place for next round */
682 int hundreds
= segment
/ 100;
683 int ones
= segment
% 100;
687 talk_id(VOICE_ZERO
+ hundreds
, true);
688 talk_id(VOICE_HUNDRED
, true);
691 /* combination indexing */
694 int tens
= ones
/10 + 18;
695 talk_id(VOICE_ZERO
+ tens
, true);
699 /* direct indexing */
701 talk_id(VOICE_ZERO
+ ones
, true);
703 /* add billion, million, thousand */
705 talk_id(VOICE_THOUSAND
+ level
, true);
713 /* singular/plural aware saying of a value */
714 int talk_value(long n
, int unit
, bool enqueue
)
717 static const int unit_voiced
[] =
718 { /* lookup table for the voice ID of the units */
719 -1, -1, -1, /* regular ID, int, signed */
720 VOICE_MILLISECONDS
, /* here come the "real" units */
733 #if CONFIG_CODEC != SWCODEC
734 if (audio_status()) /* busy, buffer in use */
738 if (unit
< 0 || unit
>= UNIT_LAST
)
741 unit_id
= unit_voiced
[unit
];
743 if ((n
==1 || n
==-1) /* singular? */
744 && unit_id
>= VOICE_SECONDS
&& unit_id
<= VOICE_HOURS
)
746 unit_id
--; /* use the singular for those units which have */
749 /* special case with a "plus" before */
750 if (n
> 0 && (unit
== UNIT_SIGNED
|| unit
== UNIT_DB
))
752 talk_id(VOICE_PLUS
, enqueue
);
756 talk_number(n
, enqueue
); /* say the number */
757 talk_id(unit_id
, true); /* say the unit, if any */
763 int talk_spell(const char* spell
, bool enqueue
)
765 char c
; /* currently processed char */
767 #if CONFIG_CODEC != SWCODEC
768 if (audio_status()) /* busy, buffer in use */
773 shutup(); /* cut off all the pending stuff */
775 while ((c
= *spell
++) != '\0')
777 /* if this grows into too many cases, I should use a table */
778 if (c
>= 'A' && c
<= 'Z')
779 talk_id(VOICE_CHAR_A
+ c
- 'A', true);
780 else if (c
>= 'a' && c
<= 'z')
781 talk_id(VOICE_CHAR_A
+ c
- 'a', true);
782 else if (c
>= '0' && c
<= '9')
783 talk_id(VOICE_ZERO
+ c
- '0', true);
785 talk_id(VOICE_MINUS
, true);
787 talk_id(VOICE_PLUS
, true);
789 talk_id(VOICE_DOT
, true);
791 talk_id(VOICE_PAUSE
, true);