blob: a54325192e9eaff157bcf4e43edd6949f99e4189 [file] [log] [blame]
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2004 Jörg Hohensohn
*
* This module collects the Talkbox and voice UI functions.
* (Talkbox reads directory names from mp3 clips called thumbnails,
* the voice UI lets menus and screens "talk" from a voicefont in memory.
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <stddef.h>
#include "file.h"
#include "buffer.h"
#include "system.h"
#include "mp3_playback.h"
#include "mpeg.h"
#include "lang.h"
#include "talk.h"
#include "screens.h" /* test hack */
extern void bitswap(unsigned char *data, int length); /* no header for this */
/***************** Constants *****************/
#define QUEUE_SIZE 20
const char* voicefont_file = "/.rockbox/langs/english.voice";
/***************** Data types *****************/
struct clip_entry /* one entry of the index table */
{
int offset; /* offset from start of voicefont file */
int size; /* size of the clip */
};
struct voicefont /* file format of our "voicefont" */
{
int version; /* version of the voicefont */
int headersize; /* size of the header, =offset to index */
int id_max; /* number of clips contained */
struct clip_entry index[]; /* followed by the index table */
/* and finally the bitswapped mp3 clips, not visible here */
};
struct queue_entry /* one entry of the internal queue */
{
unsigned char* buf;
int len;
};
/***************** Globals *****************/
static unsigned char* p_thumbnail; /* buffer for thumbnail */
static long size_for_thumbnail; /* leftover buffer size for it */
static struct voicefont* p_voicefont; /* loaded voicefont */
static bool has_voicefont; /* a voicefont file is present */
static bool is_playing; /* we're currently playing */
static struct queue_entry queue[QUEUE_SIZE]; /* queue of scheduled clips */
static int queue_write; /* write index of queue, by application */
static int queue_read; /* read index of queue, by ISR context */
/***************** Private prototypes *****************/
static int load_voicefont(void);
static void mp3_callback(unsigned char** start, int* size);
static int shutup(void);
static int queue_clip(unsigned char* buf, int size, bool enqueue);
/***************** Private implementation *****************/
static int load_voicefont(void)
{
int fd;
int size;
p_voicefont = NULL; /* indicate no voicefont if we fail below */
fd = open(voicefont_file, O_RDONLY);
if (fd < 0) /* failed to open */
{
p_voicefont = NULL; /* indicate no voicefont */
has_voicefont = false; /* don't try again */
return 0;
}
size = read(fd, mp3buf, mp3end - mp3buf);
if (size > 1000
&& ((struct voicefont*)mp3buf)->headersize
== offsetof(struct voicefont, index))
{
p_voicefont = (struct voicefont*)mp3buf;
/* thumbnail buffer is the remaining space behind */
p_thumbnail = mp3buf + size;
p_thumbnail += (int)p_thumbnail % 2; /* 16-bit align */
size_for_thumbnail = mp3end - p_thumbnail;
}
else
{
has_voicefont = false; /* don't try again */
}
close(fd);
return size;
}
/* called in ISR context if mp3 data got consumed */
static void mp3_callback(unsigned char** start, int* size)
{
int play_now;
if (queue[queue_read].len > 0) /* current clip not finished? */
{ /* feed the next 64K-1 chunk */
play_now = MIN(queue[queue_read].len, 0xFFFF);
*start = queue[queue_read].buf;
*size = play_now;
queue[queue_read].buf += play_now;
queue[queue_read].len -= play_now;
return;
}
else /* go to next entry */
{
queue_read++;
if (queue_read >= QUEUE_SIZE)
queue_read = 0;
}
if (queue_read != queue_write) /* queue is not empty? */
{ /* start next clip */
play_now = MIN(queue[queue_read].len, 0xFFFF);
*start = queue[queue_read].buf;
*size = play_now;
queue[queue_read].buf += play_now;
queue[queue_read].len -= play_now;
}
else
{
*size = 0; /* end of data */
is_playing = false;
mp3_play_stop(); /* fixme: should be done by caller */
}
}
/* stop the playback and the pending clips, but at frame boundary */
static int shutup(void)
{
unsigned char* pos;
unsigned char* search;
unsigned char* end;
mp3_play_pause(false); /* pause */
if (!is_playing) /* has ended anyway */
return 0;
/* search next frame boundary and continue up to there */
pos = search = mp3_get_pos();
end = queue[queue_read].buf + queue[queue_read].len;
while (search < end) /* search the remaining data */
{
if (*search++ != 0xFF) /* search for frame sync byte */
{
continue;
}
/* look at the (bitswapped) 2nd byte of header candidate */
if ((*search & 0x07) == 0x07 /* rest of frame sync */
&& (*search & 0x18) != 0x10 /* version != reserved */
&& (*search & 0x60) != 0x00) /* layer != reserved */
{
break; /* From looking at the first 2 bytes, this is a header. */
/* this is not a sufficient condition to find header,
may give "false alert" (end too early), but a start */
}
}
queue_write = queue_read; /* reset the queue */
is_playing = false;
/* play old data until the frame end, to keep the MAS in sync */
if (search-pos)
queue_clip(pos, search-pos, true);
/* If the voice clips contain dependent frames (currently they don't),
it may be a good idea to insert an independent dummy frame here. */
return 0;
}
/* schedule a clip, at the end or discard the existing queue */
static int queue_clip(unsigned char* buf, int size, bool enqueue)
{
if (!enqueue)
shutup(); /* cut off all the pending stuff */
queue[queue_write].buf = buf;
queue[queue_write].len = size;
/* FixMe: make this IRQ-safe */
if (!is_playing)
{ /* queue empty, we have to do the initial start */
int size_now = MIN(size, 0xFFFF); /* DMA can do no more */
is_playing = true;
mp3_play_data(buf, size_now, mp3_callback);
mp3_play_pause(true); /* kickoff audio */
queue[queue_write].buf += size_now;
queue[queue_write].len -= size_now;
}
queue_write++;
if (queue_write >= QUEUE_SIZE)
queue_write = 0;
return 0;
}
/***************** Public implementation *****************/
void talk_init(void)
{
int fd;
fd = open(voicefont_file, O_RDONLY);
if (fd >= 0) /* success */
{
close(fd);
has_voicefont = true;
}
else
{
has_voicefont = false; /* no voice file available */
}
talk_buffer_steal(); /* abuse this for most of our inits */
queue_write = queue_read = 0;
}
/* somebody else claims the mp3 buffer, e.g. for regular play/record */
int talk_buffer_steal(void)
{
p_voicefont = NULL; /* indicate no voicefont (trashed) */
p_thumbnail = mp3buf; /* whole space for thumbnail */
size_for_thumbnail = mp3end - mp3buf;
return 0;
}
/* play a voice ID from voicefont */
int talk_id(int id, bool enqueue)
{
int clipsize;
unsigned char* clipbuf;
int unit;
if (mpeg_status()) /* busy, buffer in use */
return -1;
if (p_voicefont == NULL && has_voicefont)
load_voicefont(); /* reload needed */
if (p_voicefont == NULL) /* still no voices? */
return -1;
/* check if this is a special ID, with a value */
unit = ((unsigned)id) >> UNIT_SHIFT;
if (id != -1 && unit)
{ /* sign-extend the value */
//splash(200, true,"unit=%d", unit);
id = (unsigned)id << (32-UNIT_SHIFT);
id >>= (32-UNIT_SHIFT);
talk_value(id, unit, enqueue); /* speak it */
return 0; /* and stop, end of special case */
}
if (id < 0 || id >= p_voicefont->id_max)
return -1;
clipsize = p_voicefont->index[id].size;
if (clipsize == 0) /* clip not included in voicefont */
return -1;
clipbuf = mp3buf + p_voicefont->index[id].offset;
queue_clip(clipbuf, clipsize, enqueue);
return 0;
}
/* play a thumbnail from file */
int talk_file(char* filename, bool enqueue)
{
int fd;
int size;
if (mpeg_status()) /* busy, buffer in use */
return -1;
if (p_thumbnail == NULL || size_for_thumbnail <= 0)
return -1;
fd = open(filename, O_RDONLY);
if (fd < 0) /* failed to open */
{
return 0;
}
size = read(fd, p_thumbnail, size_for_thumbnail);
close(fd);
/* ToDo: find audio, skip ID headers and trailers */
if (size)
{
bitswap(p_thumbnail, size);
queue_clip(p_thumbnail, size, enqueue);
}
return size;
}
/* say a numeric value, this word ordering works for english,
but not necessarily for other languages (e.g. german) */
int talk_number(int n, bool enqueue)
{
int level = 0; /* mille count */
int mil = 1000000000; /* highest possible "-illion" */
if (!enqueue)
shutup(); /* cut off all the pending stuff */
if (n==0)
{ /* special case */
talk_id(VOICE_ZERO, true);
return 0;
}
if (n<0)
{
talk_id(VOICE_MINUS, true);
n = -n;
}
while (n)
{
int segment = n / mil; /* extract in groups of 3 digits */
n -= segment * mil; /* remove the used digits from number */
mil /= 1000; /* digit place for next round */
if (segment)
{
int hundreds = segment / 100;
int ones = segment % 100;
if (hundreds)
{
talk_id(VOICE_ZERO + hundreds, true);
talk_id(VOICE_HUNDRED, true);
}
/* combination indexing */
if (ones > 20)
{
int tens = ones/10 + 18;
talk_id(VOICE_ZERO + tens, true);
ones %= 10;
}
/* direct indexing */
if (ones)
talk_id(VOICE_ZERO + ones, true);
/* add billion, million, thousand */
if (mil)
talk_id(VOICE_BILLION + level, true);
}
level++;
}
return 0;
}
int talk_value(int n, int unit, bool enqueue)
{
int unit_id;
const int unit_voiced[] =
{ /* lookup table for the voice ID of the units */
-1, -1, -1, /* regular ID, int, signed */
VOICE_MILLISECONDS, /* here come the "real" units */
VOICE_SECONDS,
VOICE_MINUTES,
VOICE_HOURS,
VOICE_KHZ,
VOICE_DB,
VOICE_PERCENT,
VOICE_MEGABYTE,
VOICE_GIGABYTE,
VOICE_MILLIAMPHOURS,
VOICE_PIXEL,
VOICE_PER_SEC,
VOICE_HERTZ,
};
if (unit < 0 || unit >= UNIT_LAST)
unit_id = -1;
else
unit_id = unit_voiced[unit];
if ((n==1 || n==-1) /* singular? */
&& unit_id >= VOICE_SECONDS && unit_id <= VOICE_HOURS)
{
unit_id--; /* use the singular for those units which have */
}
/* special case with a "plus" before */
if (n > 0 && (unit == UNIT_SIGNED || unit == UNIT_DB))
{
talk_id(VOICE_PLUS, enqueue);
enqueue = true;
}
talk_number(n, enqueue); /* say the number */
talk_id(unit_id, true); /* say the unit, if any */
return 0;
}