rockbox/apps/talk.c

/***************************************************************************
 *             __________               __   ___.
 *   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 "id3.h"
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";
const char* dir_thumbnail_name = ".dirname.mp3";


/***************** 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 table;   /* offset to index table, (=header size) */
    int id1_max; /* number of "normal" clips contained in above index */
    int id2_max; /* number of "voice only" clips contained in above index */
    struct clip_entry index[]; /* followed by the index tables */
    /* 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)->table
           == 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;
    /* one silent bitswapped mp3 frame (22kHz), without bit reservoir */
    static const unsigned char silent_frame[] = {
        0xFF,0xCF,0x08,0x23,0x00,0x00,0x00,0xC0,0x12,0x80,0x01,0x00,0x00,
        0x32,0x82,0xB2,0xA2,0xCC,0x74,0x9C,0xCC,0xAA,0xAA,0xAA,0xAA,0xAA,
    };

    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;

    /* Find the next frame boundary */
    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 */
        {
            search--; /* back to the sync byte */
            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. */
    queue_clip((unsigned char*)silent_frame, sizeof(silent_frame), true);
    
    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;

    if (id == -1) /* -1 is an indication for silence */
        return -1;

    /* check if this is a special ID, with a value */
    unit = ((unsigned)id) >> UNIT_SHIFT;
    if (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 > VOICEONLY_DELIMITER)
    {   /* voice-only entries use the second part of the table */
        id -= VOICEONLY_DELIMITER + 1;
        if (id >= p_voicefont->id2_max)
            return -1; /* must be newer than we have */
        id += p_voicefont->id1_max; /* table 2 is behind table 1 */
    }
    else
    {   /* normal use of the first table */
        if (id >= p_voicefont->id1_max)
            return -1; /* must be newer than we have */
    }
    
    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;
    struct mp3entry info;

    if (mpeg_status()) /* busy, buffer in use */
        return -1; 

    if (p_thumbnail == NULL || size_for_thumbnail <= 0)
        return -1;

    if(mp3info(&info, filename)) /* use this to find real start */
    {   
        return 0; /* failed to open, or invalid */
    }

    fd = open(filename, O_RDONLY);
    if (fd < 0) /* failed to open */
    {
        return 0;
    }

    lseek(fd, info.first_frame_offset, SEEK_SET); /* behind ID data */

    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 (mpeg_status()) /* busy, buffer in use */
        return -1; 

    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 (mpeg_status()) /* busy, buffer in use */
        return -1; 

    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;
}