apps/talk.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 Jörg Hohensohn
  11  *
  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.
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  22  * KIND, either express or implied.
  23  *
  24  ****************************************************************************/
  25
  26 #include <stdio.h>
  27 #include <stddef.h>
  28 #include "string-extra.h"
  29 #include "file.h"
  30 #include "buffer.h"
  31 #include "system.h"
  32 #include "kernel.h"
  33 #include "settings.h"
  34 #include "settings_list.h"
  35 #include "mp3_playback.h"
  36 #include "audio.h"
  37 #include "lang.h"
  38 #include "talk.h"
  39 #include "metadata.h"
  40 /*#define LOGF_ENABLE*/
  41 #include "logf.h"
  42 #include "bitswap.h"
  43 #include "structec.h"
  44 #include "debug.h"
  45
  46
  47 /* Memory layout varies between targets because the
  48    Archos (MASCODEC) devices cannot mix voice and audio playback
  49
  50              MASCODEC  | MASCODEC  | SWCODEC
  51              (playing) | (stopped) |
  52     audiobuf-----------+-----------+------------
  53               audio    | voice     | thumbnail
  54                        |-----------|------------
  55                        | thumbnail | voice
  56                        |           |------------
  57                        |           | filebuf
  58                        |           |------------
  59                        |           | audio
  60   audiobufend----------+-----------+------------
  61
  62   SWCODEC allocates dedicated buffers, MASCODEC reuses audiobuf. */
  63
  64
  65 /***************** Constants *****************/
  66
  67 #define QUEUE_SIZE 64 /* must be a power of two */
  68 #define QUEUE_MASK (QUEUE_SIZE-1)
  69 const char* const dir_thumbnail_name = "_dirname.talk";
  70 const char* const file_thumbnail_ext = ".talk";
  71
  72 /***************** Functional Macros *****************/
  73
  74 #define QUEUE_LEVEL ((queue_write - queue_read) & QUEUE_MASK)
  75
  76 #define LOADED_MASK 0x80000000 /* MSB */
  77
  78 #if CONFIG_CODEC == SWCODEC
  79 #define MAX_THUMBNAIL_BUFSIZE 0x10000
  80 #endif
  81
  82 /***************** Data types *****************/
  83
  84 struct clip_entry /* one entry of the index table */
  85 {
  86     int offset; /* offset from start of voicefile file */
  87     int size; /* size of the clip */
  88 };
  89
  90 struct voicefile /* file format of our voice file */
  91 {
  92     int version; /* version of the voicefile */
  93     int target_id; /* the rockbox target the file was made for */
  94     int table;   /* offset to index table, (=header size) */
  95     int id1_max; /* number of "normal" clips contained in above index */
  96     int id2_max; /* number of "voice only" clips contained in above index */
  97     struct clip_entry index[]; /* followed by the index tables */
  98     /* and finally the mp3 clips, not visible here, bitswapped
  99        for SH based players */
 100 };
 101
 102 struct queue_entry /* one entry of the internal queue */
 103 {
 104     unsigned char* buf;
 105     long len;
 106 };
 107
 108
 109 /***************** Globals *****************/
 110
 111 static unsigned char* p_thumbnail = NULL; /* buffer for thumbnails */
 112 /* Multiple thumbnails can be loaded back-to-back in this buffer. */
 113 static volatile int thumbnail_buf_used SHAREDBSS_ATTR; /* length of data in
 114                                                           thumbnail buffer */
 115 static long size_for_thumbnail; /* total thumbnail buffer size */
 116 static struct voicefile* p_voicefile; /* loaded voicefile */
 117 static bool has_voicefile; /* a voicefile file is present */
 118 static bool need_shutup; /* is there possibly any voice playing to be shutup */
 119 static struct queue_entry queue[QUEUE_SIZE]; /* queue of scheduled clips */
 120 static bool force_enqueue_next; /* enqueue next utterance even if enqueue is false */
 121 static int queue_write; /* write index of queue, by application */
 122 static int queue_read; /* read index of queue, by ISR context */
 123 #if CONFIG_CODEC == SWCODEC
 124 /* protects queue_read, queue_write and thumbnail_buf_used */
 125 static struct mutex queue_mutex SHAREDBSS_ATTR;
 126 #define talk_queue_lock() ({ mutex_lock(&queue_mutex); })
 127 #define talk_queue_unlock() ({ mutex_unlock(&queue_mutex); })
 128 #else
 129 #define talk_queue_lock() ({ })
 130 #define talk_queue_unlock() ({ })
 131 #endif /* CONFIG_CODEC */
 132 static int sent; /* how many bytes handed over to playback, owned by ISR */
 133 static unsigned char curr_hd[3]; /* current frame header, for re-sync */
 134 static int filehandle = -1; /* global, so the MMC variant can keep the file open */
 135 static unsigned char* p_silence; /* VOICE_PAUSE clip, used for termination */
 136 static long silence_len; /* length of the VOICE_PAUSE clip */
 137 static unsigned char* p_lastclip; /* address of latest clip, for silence add */
 138 static unsigned long voicefile_size = 0; /* size of the loaded voice file */
 139 static unsigned char last_lang[MAX_FILENAME+1]; /* name of last used lang file (in talk_init) */
 140 static bool talk_initialized; /* true if talk_init has been called */
 141 static int talk_temp_disable_count; /* if positive, temporarily disable voice UI (not saved) */
 142
 143
 144 /***************** Private implementation *****************/
 145
 146 static int open_voicefile(void)
 147 {
 148     char buf[64];
 149     char* p_lang = "english"; /* default */
 150
 151     if ( global_settings.lang_file[0] &&
 152          global_settings.lang_file[0] != 0xff )
 153     {   /* try to open the voice file of the selected language */
 154         p_lang = (char *)global_settings.lang_file;
 155     }
 156
 157     snprintf(buf, sizeof(buf), LANG_DIR "/%s.voice", p_lang);
 158
 159     return open(buf, O_RDONLY);
 160 }
 161
 162
 163 /* fetch a clip from the voice file */
 164 static unsigned char* get_clip(long id, long* p_size)
 165 {
 166     long clipsize;
 167     unsigned char* clipbuf;
 168
 169     if (id > VOICEONLY_DELIMITER)
 170     {   /* voice-only entries use the second part of the table */
 171         id -= VOICEONLY_DELIMITER + 1;
 172         if (id >= p_voicefile->id2_max)
 173             return NULL; /* must be newer than we have */
 174         id += p_voicefile->id1_max; /* table 2 is behind table 1 */
 175     }
 176     else
 177     {   /* normal use of the first table */
 178         if (id >= p_voicefile->id1_max)
 179             return NULL; /* must be newer than we have */
 180     }
 181
 182     clipsize = p_voicefile->index[id].size;
 183     if (clipsize == 0) /* clip not included in voicefile */
 184         return NULL;
 185     clipbuf = (unsigned char *) p_voicefile + p_voicefile->index[id].offset;
 186
 187 #if (CONFIG_STORAGE & STORAGE_MMC) /* dynamic loading, on demand */
 188     if (!(clipsize & LOADED_MASK))
 189     {   /* clip used for the first time, needs loading */
 190         lseek(filehandle, p_voicefile->index[id].offset, SEEK_SET);
 191         if (read(filehandle, clipbuf, clipsize) != clipsize)
 192             return NULL; /* read error */
 193
 194         p_voicefile->index[id].size |= LOADED_MASK; /* mark as loaded */
 195     }
 196     else
 197     {   /* clip is in memory already */
 198         clipsize &= ~LOADED_MASK; /* without the extra bit gives true size */
 199     }
 200 #endif
 201
 202     *p_size = clipsize;
 203     return clipbuf;
 204 }
 205
 206
 207 /* load the voice file into the mp3 buffer */
 208 static void load_voicefile(void)
 209 {
 210     int load_size;
 211     int got_size;
 212     int file_size;
 213 #ifdef ROCKBOX_LITTLE_ENDIAN
 214     int i;
 215 #endif
 216
 217     filehandle = open_voicefile();
 218     if (filehandle < 0) /* failed to open */
 219         goto load_err;
 220
 221     file_size = filesize(filehandle);
 222     if (file_size > audiobufend - audiobuf) /* won't fit? */
 223         goto load_err;
 224
 225 #if (CONFIG_STORAGE & STORAGE_MMC) /* load only the header for now */
 226     load_size = offsetof(struct voicefile, index);
 227 #else /* load the full file */
 228     load_size = file_size;
 229 #endif
 230
 231     got_size = read(filehandle, audiobuf, load_size);
 232     if (got_size != load_size /* failure */)
 233         goto load_err;
 234
 235 #ifdef ROCKBOX_LITTLE_ENDIAN
 236     logf("Byte swapping voice file");
 237     structec_convert(audiobuf, "lllll", 1, true);
 238 #endif
 239
 240     if (((struct voicefile*)audiobuf)->table /* format check */
 241            == offsetof(struct voicefile, index))
 242     {
 243         p_voicefile = (struct voicefile*)audiobuf;
 244
 245         if (p_voicefile->version != VOICE_VERSION ||
 246             p_voicefile->target_id != TARGET_ID)
 247         {
 248             logf("Incompatible voice file");
 249             goto load_err;
 250         }
 251 #if CONFIG_CODEC != SWCODEC
 252         /* MASCODEC: now use audiobuf for voice then thumbnail */
 253         p_thumbnail = audiobuf + file_size;
 254         p_thumbnail += (long)p_thumbnail % 2; /* 16-bit align */
 255         size_for_thumbnail = audiobufend - p_thumbnail;
 256 #endif
 257     }
 258     else
 259         goto load_err;
 260
 261 #ifdef ROCKBOX_LITTLE_ENDIAN
 262     for (i = 0; i < p_voicefile->id1_max + p_voicefile->id2_max; i++)
 263         structec_convert(&p_voicefile->index[i], "ll", 1, true);
 264 #endif
 265
 266 #if (CONFIG_STORAGE & STORAGE_MMC)
 267     /* load the index table, now that we know its size from the header */
 268     load_size = (p_voicefile->id1_max + p_voicefile->id2_max)
 269                 * sizeof(struct clip_entry);
 270     got_size = read(filehandle,
 271                     (unsigned char *) p_voicefile + offsetof(struct voicefile, index), load_size);
 272     if (got_size != load_size) /* read error */
 273         goto load_err;
 274 #else
 275     close(filehandle); /* only the MMC variant leaves it open */
 276     filehandle = -1;
 277 #endif
 278
 279     /* make sure to have the silence clip, if available */
 280     p_silence = get_clip(VOICE_PAUSE, &silence_len);
 281
 282     return;
 283
 284 load_err:
 285     p_voicefile = NULL;
 286     has_voicefile = false; /* don't try again */
 287     if (filehandle >= 0)
 288     {
 289         close(filehandle);
 290         filehandle = -1;
 291     }
 292     return;
 293 }
 294
 295
 296 /* called in ISR context if mp3 data got consumed */
 297 static void mp3_callback(unsigned char** start, size_t* size)
 298 {
 299     queue[queue_read].len -= sent; /* we completed this */
 300     queue[queue_read].buf += sent;
 301
 302     if (queue[queue_read].len > 0) /* current clip not finished? */
 303     {   /* feed the next 64K-1 chunk */
 304 #if CONFIG_CODEC != SWCODEC
 305         sent = MIN(queue[queue_read].len, 0xFFFF);
 306 #else
 307         sent = queue[queue_read].len;
 308 #endif
 309         *start = queue[queue_read].buf;
 310         *size = sent;
 311         return;
 312     }
 313     talk_queue_lock();
 314     if(p_thumbnail
 315        && queue[queue_read].buf == p_thumbnail +thumbnail_buf_used)
 316         thumbnail_buf_used = 0;
 317     if (sent > 0) /* go to next entry */
 318     {
 319         queue_read = (queue_read + 1) & QUEUE_MASK;
 320     }
 321
 322 re_check:
 323
 324     if (QUEUE_LEVEL != 0) /* queue is not empty? */
 325     {   /* start next clip */
 326 #if CONFIG_CODEC != SWCODEC
 327         sent = MIN(queue[queue_read].len, 0xFFFF);
 328 #else
 329         sent = queue[queue_read].len;
 330 #endif
 331         *start = p_lastclip = queue[queue_read].buf;
 332         *size = sent;
 333         curr_hd[0] = p_lastclip[1];
 334         curr_hd[1] = p_lastclip[2];
 335         curr_hd[2] = p_lastclip[3];
 336     }
 337     else if (p_silence != NULL             /* silence clip available */
 338              && p_lastclip != p_silence    /* previous clip wasn't silence */
 339              && !(p_lastclip >= p_thumbnail /* ..or thumbnail */
 340                   && p_lastclip < p_thumbnail +size_for_thumbnail))
 341     {   /* add silence clip when queue runs empty playing a voice clip */
 342         queue[queue_write].buf = p_silence;
 343         queue[queue_write].len = silence_len;
 344         queue_write = (queue_write + 1) & QUEUE_MASK;
 345
 346         goto re_check;
 347     }
 348     else
 349     {
 350         *size = 0; /* end of data */
 351     }
 352     talk_queue_unlock();
 353 }
 354
 355 /***************** Public routines *****************/
 356
 357 /* stop the playback and the pending clips */
 358 void talk_force_shutup(void)
 359 {
 360     /* Most of this is MAS only */
 361 #if CONFIG_CODEC != SWCODEC
 362 #ifdef SIMULATOR
 363     return;
 364 #endif
 365     unsigned char* pos;
 366     unsigned char* search;
 367     unsigned char* end;
 368     if (QUEUE_LEVEL == 0) /* has ended anyway */
 369         return;
 370
 371 #if CONFIG_CPU == SH7034
 372     CHCR3 &= ~0x0001; /* disable the DMA (and therefore the interrupt also) */
 373 #endif /* CONFIG_CPU == SH7034 */
 374     /* search next frame boundary and continue up to there */
 375     pos = search = mp3_get_pos();
 376     end = queue[queue_read].buf + queue[queue_read].len;
 377
 378     if (pos >= queue[queue_read].buf
 379         && pos <= end) /* really our clip? */
 380     { /* (for strange reasons this isn't nesessarily the case) */
 381         /* find the next frame boundary */
 382         while (search < end) /* search the remaining data */
 383         {
 384             if (*search++ != 0xFF) /* quick search for frame sync byte */
 385                 continue; /* (this does the majority of the job) */
 386
 387             /* look at the (bitswapped) rest of header candidate */
 388             if (search[0] == curr_hd[0] /* do the quicker checks first */
 389              && search[2] == curr_hd[2]
 390              && (search[1] & 0x30) == (curr_hd[1] & 0x30)) /* sample rate */
 391             {
 392                 search--; /* back to the sync byte */
 393                 break; /* From looking at it, this is our header. */
 394             }
 395         }
 396
 397         if (search-pos)
 398         {   /* play old data until the frame end, to keep the MAS in sync */
 399             sent = search-pos;
 400
 401             queue_write = (queue_read + 1) & QUEUE_MASK; /* will be empty after next callback */
 402             queue[queue_read].len = sent; /* current one ends after this */
 403
 404 #if CONFIG_CPU == SH7034
 405             DTCR3 = sent; /* let the DMA finish this frame */
 406             CHCR3 |= 0x0001; /* re-enable DMA */
 407 #endif /* CONFIG_CPU == SH7034 */
 408             thumbnail_buf_used = 0;
 409             return;
 410         }
 411     }
 412 #endif /* CONFIG_CODEC != SWCODEC */
 413
 414     /* Either SWCODEC, or MAS had nothing to do (was frame boundary or not our clip) */
 415     mp3_play_stop();
 416     talk_queue_lock();
 417     queue_write = queue_read = 0; /* reset the queue */
 418     thumbnail_buf_used = 0;
 419     talk_queue_unlock();
 420     need_shutup = false;
 421 }
 422
 423 /* Shutup the voice, except if force_enqueue_next is set. */
 424 void talk_shutup(void)
 425 {
 426     if (need_shutup && !force_enqueue_next)
 427         talk_force_shutup();
 428 }
 429
 430 /* schedule a clip, at the end or discard the existing queue */
 431 static void queue_clip(unsigned char* buf, long size, bool enqueue)
 432 {
 433     int queue_level;
 434
 435     if (!enqueue)
 436         talk_shutup(); /* cut off all the pending stuff */
 437     /* Something is being enqueued, force_enqueue_next override is no
 438        longer in effect. */
 439     force_enqueue_next = false;
 440
 441     if (!size)
 442         return; /* safety check */
 443 #if CONFIG_CPU == SH7034
 444     /* disable the DMA temporarily, to be safe of race condition */
 445     CHCR3 &= ~0x0001;
 446 #endif
 447     talk_queue_lock();
 448     queue_level = QUEUE_LEVEL; /* check old level */
 449
 450     if (queue_level < QUEUE_SIZE - 1) /* space left? */
 451     {
 452         queue[queue_write].buf = buf; /* populate an entry */
 453         queue[queue_write].len = size;
 454         queue_write = (queue_write + 1) & QUEUE_MASK;
 455     }
 456     talk_queue_unlock();
 457
 458     if (queue_level == 0)
 459     {   /* queue was empty, we have to do the initial start */
 460         p_lastclip = buf;
 461 #if CONFIG_CODEC != SWCODEC
 462         sent = MIN(size, 0xFFFF); /* DMA can do no more */
 463 #else
 464         sent = size;
 465 #endif
 466         mp3_play_data(buf, sent, mp3_callback);
 467         curr_hd[0] = buf[1];
 468         curr_hd[1] = buf[2];
 469         curr_hd[2] = buf[3];
 470         mp3_play_pause(true); /* kickoff audio */
 471     }
 472     else
 473     {
 474 #if CONFIG_CPU == SH7034
 475         CHCR3 |= 0x0001; /* re-enable DMA */
 476 #endif
 477     }
 478
 479     need_shutup = true;
 480
 481     return;
 482 }
 483
 484
 485 /* common code for talk_init() and talk_buffer_steal() */
 486 static void reset_state(void)
 487 {
 488     queue_write = queue_read = 0; /* reset the queue */
 489     p_voicefile = NULL; /* indicate no voicefile (trashed) */
 490 #if CONFIG_CODEC == SWCODEC
 491     /* Allocate a dedicated thumbnail buffer - once */
 492     if (p_thumbnail == NULL)
 493     {
 494         size_for_thumbnail = audiobufend - audiobuf;
 495         if (size_for_thumbnail > MAX_THUMBNAIL_BUFSIZE)
 496             size_for_thumbnail = MAX_THUMBNAIL_BUFSIZE;
 497         p_thumbnail = buffer_alloc(size_for_thumbnail);
 498     }
 499 #else
 500     /* Just use the audiobuf, without allocating anything */
 501     p_thumbnail = audiobuf;
 502     size_for_thumbnail = audiobufend - audiobuf;
 503 #endif
 504     thumbnail_buf_used = 0;
 505     p_silence = NULL; /* pause clip not accessible */
 506 }
 507
 508
 509 /***************** Public implementation *****************/
 510
 511 void talk_init(void)
 512 {
 513     talk_temp_disable_count = 0;
 514     if (talk_initialized && !strcasecmp(last_lang, global_settings.lang_file))
 515     {
 516         /* not a new file, nothing to do */
 517         return;
 518     }
 519
 520 #if (CONFIG_STORAGE & STORAGE_MMC)
 521     if (filehandle >= 0) /* MMC: An old voice file might still be open */
 522     {
 523         close(filehandle);
 524         filehandle = -1;
 525     }
 526 #endif
 527
 528 #if CONFIG_CODEC == SWCODEC
 529     if(!talk_initialized)
 530         mutex_init(&queue_mutex);
 531 #endif /* CONFIG_CODEC == SWCODEC */
 532
 533     talk_initialized = true;
 534     strlcpy((char *)last_lang, (char *)global_settings.lang_file,
 535         MAX_FILENAME);
 536
 537 #if CONFIG_CODEC == SWCODEC
 538     audio_get_buffer(false, NULL);  /* Must tell audio to reinitialize */
 539 #endif
 540     reset_state(); /* use this for most of our inits */
 541
 542     filehandle = open_voicefile();
 543     has_voicefile = (filehandle >= 0); /* test if we can open it */
 544     voicefile_size = 0;
 545
 546     if (has_voicefile)
 547     {
 548         voicefile_size = filesize(filehandle);
 549         close(filehandle); /* close again, this was just to detect presence */
 550         filehandle = -1;
 551     }
 552
 553 }
 554
 555 #if CONFIG_CODEC == SWCODEC
 556 /* return if a voice codec is required or not */
 557 bool talk_voice_required(void)
 558 {
 559     return (voicefile_size != 0) /* Voice file is available */
 560         || (global_settings.talk_dir_clip)  /* Thumbnail clips are required */
 561         || (global_settings.talk_file_clip);
 562 }
 563 #endif
 564
 565 /* return size of voice file */
 566 int talk_get_bufsize(void)
 567 {
 568     return voicefile_size;
 569 }
 570
 571 /* somebody else claims the mp3 buffer, e.g. for regular play/record */
 572 void talk_buffer_steal(void)
 573 {
 574 #if CONFIG_CODEC != SWCODEC
 575     mp3_play_stop();
 576 #endif
 577 #if (CONFIG_STORAGE & STORAGE_MMC)
 578     if (filehandle >= 0) /* only relevant for MMC */
 579     {
 580         close(filehandle);
 581         filehandle = -1;
 582     }
 583 #endif
 584     reset_state();
 585 }
 586
 587
 588 /* play a voice ID from voicefile */
 589 int talk_id(int32_t id, bool enqueue)
 590 {
 591     long clipsize;
 592     unsigned char* clipbuf;
 593     int32_t unit;
 594     int decimals;
 595
 596     if (talk_temp_disable_count > 0)
 597         return -1;  /* talking has been disabled */
 598 #if CONFIG_CODEC != SWCODEC
 599     if (audio_status()) /* busy, buffer in use */
 600         return -1;
 601 #endif
 602
 603     if (p_voicefile == NULL && has_voicefile)
 604         load_voicefile(); /* reload needed */
 605
 606     if (p_voicefile == NULL) /* still no voices? */
 607         return -1;
 608
 609     if (id == -1) /* -1 is an indication for silence */
 610         return -1;
 611
 612     decimals = (((uint32_t)id) >> DECIMAL_SHIFT) & 0x7;
 613
 614     /* check if this is a special ID, with a value */
 615     unit = ((uint32_t)id) >> UNIT_SHIFT;
 616     if (unit || decimals)
 617     {   /* sign-extend the value */
 618         id = (uint32_t)id << (32-DECIMAL_SHIFT);
 619         id >>= (32-DECIMAL_SHIFT);
 620
 621         talk_value_decimal(id, unit, decimals, enqueue); /* speak it */
 622         return 0; /* and stop, end of special case */
 623     }
 624
 625     clipbuf = get_clip(id, &clipsize);
 626     if (clipbuf == NULL)
 627         return -1; /* not present */
 628
 629     logf("\ntalk_id: Say '%s'\n", str(id));
 630     queue_clip(clipbuf, clipsize, enqueue);
 631
 632     return 0;
 633 }
 634 /* Speaks zero or more IDs (from an array). */
 635 int talk_idarray(const long *ids, bool enqueue)
 636 {
 637     int r;
 638     if(!ids)
 639         return 0;
 640     while(*ids != TALK_FINAL_ID)
 641     {
 642         if((r = talk_id(*ids++, enqueue)) <0)
 643             return r;
 644         enqueue = true;
 645     }
 646     return 0;
 647 }
 648
 649 /* Make sure the current utterance is not interrupted by the next one. */
 650 void talk_force_enqueue_next(void)
 651 {
 652     force_enqueue_next = true;
 653 }
 654
 655 /* play a thumbnail from file */
 656 /* Returns size of spoken thumbnail, so >0 means something is spoken,
 657    <=0 means something went wrong. */
 658 static int _talk_file(const char* filename,
 659                       const long *prefix_ids, bool enqueue)
 660 {
 661     int fd;
 662     int size;
 663     int thumb_used;
 664 #if CONFIG_CODEC != SWCODEC
 665     struct mp3entry info;
 666 #endif
 667
 668     if (talk_temp_disable_count > 0)
 669         return -1;  /* talking has been disabled */
 670 #if CONFIG_CODEC != SWCODEC
 671     if (audio_status()) /* busy, buffer in use */
 672         return -1;
 673 #endif
 674
 675     if (p_thumbnail == NULL || size_for_thumbnail <= 0)
 676         return -1;
 677
 678 #if CONFIG_CODEC != SWCODEC
 679     if(mp3info(&info, filename)) /* use this to find real start */
 680     {
 681         return 0; /* failed to open, or invalid */
 682     }
 683 #endif
 684
 685     if (!enqueue)
 686         /* shutup now to free the thumbnail buffer */
 687         talk_shutup();
 688
 689     fd = open(filename, O_RDONLY);
 690     if (fd < 0) /* failed to open */
 691     {
 692         return 0;
 693     }
 694
 695     thumb_used = thumbnail_buf_used;
 696     if(filesize(fd) > size_for_thumbnail -thumb_used)
 697     {   /* Don't play truncated  clips */
 698         close(fd);
 699         return 0;
 700     }
 701
 702 #if CONFIG_CODEC != SWCODEC
 703     lseek(fd, info.first_frame_offset, SEEK_SET); /* behind ID data */
 704 #endif
 705
 706     size = read(fd, p_thumbnail +thumb_used,
 707                 size_for_thumbnail -thumb_used);
 708     close(fd);
 709
 710     /* ToDo: find audio, skip ID headers and trailers */
 711
 712     if (size > 0)    /* Don't play missing clips */
 713     {
 714 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 715         bitswap(p_thumbnail, size);
 716 #endif
 717         if(prefix_ids)
 718             /* prefix thumbnail by speaking these ids, but only now
 719                that we know there's actually a thumbnail to be
 720                spoken. */
 721             talk_idarray(prefix_ids, true);
 722         talk_queue_lock();
 723         thumbnail_buf_used = thumb_used +size;
 724         talk_queue_unlock();
 725         queue_clip(p_thumbnail +thumb_used, size, true);
 726     }
 727
 728     return size;
 729 }
 730
 731 int talk_file(const char *root, const char *dir, const char *file,
 732               const char *ext, const long *prefix_ids, bool enqueue)
 733 /* Play a thumbnail file */
 734 {
 735     char buf[MAX_PATH];
 736     /* Does root end with a slash */
 737     char *slash = (root && root[0]
 738                    && root[strlen(root)-1] != '/') ? "/" : "";
 739     snprintf(buf, MAX_PATH, "%s%s%s%s%s%s",
 740              root ? root : "", slash,
 741              dir ? dir : "", dir ? "/" : "",
 742              file ? file : "",
 743              ext ? ext : "");
 744     return _talk_file(buf, prefix_ids, enqueue);
 745 }
 746
 747 static int talk_spell_basename(const char *path,
 748                                const long *prefix_ids, bool enqueue)
 749 {
 750     if(prefix_ids)
 751     {
 752         talk_idarray(prefix_ids, enqueue);
 753         enqueue = true;
 754     }
 755     char buf[MAX_PATH];
 756     /* Spell only the path component after the last slash */
 757     strlcpy(buf, path, sizeof(buf));
 758     if(strlen(buf) >1 && buf[strlen(buf)-1] == '/')
 759         /* strip trailing slash */
 760         buf[strlen(buf)-1] = '\0';
 761     char *ptr = strrchr(buf, '/');
 762     if(ptr && strlen(buf) >1)
 763         ++ptr;
 764     else ptr = buf;
 765     return talk_spell(ptr, enqueue);
 766 }
 767
 768 /* Play a file's .talk thumbnail, fallback to spelling the filename, or
 769    go straight to spelling depending on settings. */
 770 int talk_file_or_spell(const char *dirname, const char *filename,
 771                        const long *prefix_ids, bool enqueue)
 772 {
 773     if (global_settings.talk_file_clip)
 774     {   /* .talk clips enabled */
 775         if(talk_file(dirname, NULL, filename, file_thumbnail_ext,
 776                               prefix_ids, enqueue) >0)
 777             return 0;
 778     }
 779     if (global_settings.talk_file == 2)
 780         /* Either .talk clips are disabled, or as a fallback */
 781         return talk_spell_basename(filename, prefix_ids, enqueue);
 782     return 0;
 783 }
 784
 785 /* Play a directory's .talk thumbnail, fallback to spelling the filename, or
 786    go straight to spelling depending on settings. */
 787 int talk_dir_or_spell(const char* dirname,
 788                       const long *prefix_ids, bool enqueue)
 789 {
 790     if (global_settings.talk_dir_clip)
 791     {   /* .talk clips enabled */
 792         if(talk_file(dirname, NULL, dir_thumbnail_name, NULL,
 793                               prefix_ids, enqueue) >0)
 794             return 0;
 795     }
 796     if (global_settings.talk_dir == 2)
 797         /* Either .talk clips disabled or as a fallback */
 798         return talk_spell_basename(dirname, prefix_ids, enqueue);
 799     return 0;
 800 }
 801
 802 /* say a numeric value, this word ordering works for english,
 803    but not necessarily for other languages (e.g. german) */
 804 int talk_number(long n, bool enqueue)
 805 {
 806     int level = 2; /* mille count */
 807     long mil = 1000000000; /* highest possible "-illion" */
 808
 809     if (talk_temp_disable_count > 0)
 810         return -1;  /* talking has been disabled */
 811 #if CONFIG_CODEC != SWCODEC
 812     if (audio_status()) /* busy, buffer in use */
 813         return -1;
 814 #endif
 815
 816     if (!enqueue)
 817         talk_shutup(); /* cut off all the pending stuff */
 818
 819     if (n==0)
 820     {   /* special case */
 821         talk_id(VOICE_ZERO, true);
 822         return 0;
 823     }
 824
 825     if (n<0)
 826     {
 827         talk_id(VOICE_MINUS, true);
 828         n = -n;
 829     }
 830
 831     while (n)
 832     {
 833         int segment = n / mil; /* extract in groups of 3 digits */
 834         n -= segment * mil; /* remove the used digits from number */
 835         mil /= 1000; /* digit place for next round */
 836
 837         if (segment)
 838         {
 839             int hundreds = segment / 100;
 840             int ones = segment % 100;
 841
 842             if (hundreds)
 843             {
 844                 talk_id(VOICE_ZERO + hundreds, true);
 845                 talk_id(VOICE_HUNDRED, true);
 846             }
 847
 848             /* combination indexing */
 849             if (ones > 20)
 850             {
 851                int tens = ones/10 + 18;
 852                talk_id(VOICE_ZERO + tens, true);
 853                ones %= 10;
 854             }
 855
 856             /* direct indexing */
 857             if (ones)
 858                 talk_id(VOICE_ZERO + ones, true);
 859
 860             /* add billion, million, thousand */
 861             if (mil)
 862                 talk_id(VOICE_THOUSAND + level, true);
 863         }
 864         level--;
 865     }
 866
 867     return 0;
 868 }
 869
 870 /* Say time duration/interval. Input is time in seconds,
 871    say hours,minutes,seconds. */
 872 static int talk_time_unit(long secs, bool exact, bool enqueue)
 873 {
 874     int hours, mins;
 875     if (!enqueue)
 876         talk_shutup();
 877     if((hours = secs/3600)) {
 878         secs %= 3600;
 879         talk_value(hours, UNIT_HOUR, true);
 880     }
 881     if((mins = secs/60)) {
 882         secs %= 60;
 883         if(exact || !hours)
 884             talk_value(mins, UNIT_MIN, true);
 885         else talk_number(mins, true); /* don't say "minutes" */
 886     }
 887     if((exact && secs) || (!hours && !mins))
 888         talk_value(secs, UNIT_SEC, true);
 889     else if(!hours && secs)
 890         talk_number(secs, true);
 891     return 0;
 892 }
 893
 894 void talk_fractional(char *tbuf, int value, int unit)
 895 {
 896     int i;
 897     /* strip trailing zeros from the fraction */
 898     for (i = strlen(tbuf) - 1; (i >= 0) && (tbuf[i] == '0'); i--)
 899         tbuf[i] = '\0';
 900
 901     talk_number(value, true);
 902     if (tbuf[0] != 0)
 903     {
 904         talk_id(LANG_POINT, true);
 905         talk_spell(tbuf, true);
 906     }
 907     talk_id(unit, true);
 908 }
 909
 910 int talk_value(long n, int unit, bool enqueue)
 911 {
 912     return talk_value_decimal(n, unit, 0, enqueue);
 913 }
 914
 915 /* singular/plural aware saying of a value */
 916 int talk_value_decimal(long n, int unit, int decimals, bool enqueue)
 917 {
 918     int unit_id;
 919     static const int unit_voiced[] =
 920     {   /* lookup table for the voice ID of the units */
 921         [0 ... UNIT_LAST-1] = -1, /* regular ID, int, signed */
 922         [UNIT_MS]
 923             = VOICE_MILLISECONDS, /* here come the "real" units */
 924         [UNIT_SEC]
 925             = VOICE_SECONDS,
 926         [UNIT_MIN]
 927             = VOICE_MINUTES,
 928         [UNIT_HOUR]
 929             = VOICE_HOURS,
 930         [UNIT_KHZ]
 931             = VOICE_KHZ,
 932         [UNIT_DB]
 933             = VOICE_DB,
 934         [UNIT_PERCENT]
 935             = VOICE_PERCENT,
 936         [UNIT_MAH]
 937             = VOICE_MILLIAMPHOURS,
 938         [UNIT_PIXEL]
 939             = VOICE_PIXEL,
 940         [UNIT_PER_SEC]
 941             = VOICE_PER_SEC,
 942         [UNIT_HERTZ]
 943             = VOICE_HERTZ,
 944         [UNIT_MB]
 945             = LANG_MEGABYTE,
 946         [UNIT_KBIT]
 947             = VOICE_KBIT_PER_SEC,
 948         [UNIT_PM_TICK]
 949             = VOICE_PM_UNITS_PER_TICK,
 950     };
 951
 952     static const int pow10[] = { /* 10^0 - 10^7 */
 953         1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
 954     };
 955
 956     char tbuf[8];
 957     char fmt[] = "%0nd";
 958
 959     if (talk_temp_disable_count > 0)
 960         return -1;  /* talking has been disabled */
 961 #if CONFIG_CODEC != SWCODEC
 962     if (audio_status()) /* busy, buffer in use */
 963         return -1;
 964 #endif
 965
 966     /* special case for time duration */
 967     if (unit == UNIT_TIME || unit == UNIT_TIME_EXACT)
 968         return talk_time_unit(n, unit == UNIT_TIME_EXACT, enqueue);
 969
 970     if (unit < 0 || unit >= UNIT_LAST)
 971         unit_id = -1;
 972     else
 973         unit_id = unit_voiced[unit];
 974
 975     if ((n==1 || n==-1) /* singular? */
 976         && unit_id >= VOICE_SECONDS && unit_id <= VOICE_HOURS)
 977     {
 978         unit_id--; /* use the singular for those units which have */
 979     }
 980
 981     /* special case with a "plus" before */
 982     if (n > 0 && (unit == UNIT_SIGNED || unit == UNIT_DB))
 983     {
 984         talk_id(VOICE_PLUS, enqueue);
 985         enqueue = true;
 986     }
 987
 988     if (decimals)
 989     {
 990         /* needed for the "-0.5" corner case */
 991         if (n < 0)
 992         {
 993             talk_id(VOICE_MINUS, enqueue);
 994             n = -n;
 995         }
 996
 997         fmt[2] = '0' + decimals;
 998
 999         snprintf(tbuf, sizeof(tbuf), fmt, n % pow10[decimals]);
1000         talk_fractional(tbuf, n / pow10[decimals], unit_id);
1001
1002         return 0;
1003     }
1004
1005     talk_number(n, enqueue); /* say the number */
1006     talk_id(unit_id, true); /* say the unit, if any */
1007
1008     return 0;
1009 }
1010
1011 /* spell a string */
1012 int talk_spell(const char* spell, bool enqueue)
1013 {
1014     char c; /* currently processed char */
1015
1016     if (talk_temp_disable_count > 0)
1017         return -1;  /* talking has been disabled */
1018 #if CONFIG_CODEC != SWCODEC
1019     if (audio_status()) /* busy, buffer in use */
1020         return -1;
1021 #endif
1022
1023     if (!enqueue)
1024         talk_shutup(); /* cut off all the pending stuff */
1025
1026     while ((c = *spell++) != '\0')
1027     {
1028         /* if this grows into too many cases, I should use a table */
1029         if (c >= 'A' && c <= 'Z')
1030             talk_id(VOICE_CHAR_A + c - 'A', true);
1031         else if (c >= 'a' && c <= 'z')
1032             talk_id(VOICE_CHAR_A + c - 'a', true);
1033         else if (c >= '0' && c <= '9')
1034             talk_id(VOICE_ZERO + c - '0', true);
1035         else if (c == '-')
1036             talk_id(VOICE_MINUS, true);
1037         else if (c == '+')
1038             talk_id(VOICE_PLUS, true);
1039         else if (c == '.')
1040             talk_id(VOICE_DOT, true);
1041         else if (c == ' ')
1042             talk_id(VOICE_PAUSE, true);
1043         else if (c == '/')
1044             talk_id(VOICE_CHAR_SLASH, true);
1045     }
1046
1047     return 0;
1048 }
1049
1050 void talk_disable(bool disable)
1051 {
1052     if (disable)
1053         talk_temp_disable_count++;
1054     else
1055         talk_temp_disable_count--;
1056 }
1057
1058 void talk_setting(const void *global_settings_variable)
1059 {
1060     const struct settings_list *setting;
1061     if (!global_settings.talk_menu)
1062         return;
1063     setting = find_setting(global_settings_variable, NULL);
1064     if (setting == NULL)
1065         return;
1066     if (setting->lang_id)
1067         talk_id(setting->lang_id,false);
1068 }
1069
1070
1071 #if CONFIG_RTC
1072 void talk_date(const struct tm *tm, bool enqueue)
1073 {
1074     talk_id(LANG_MONTH_JANUARY + tm->tm_mon, enqueue);
1075     talk_number(tm->tm_mday, true);
1076     talk_number(1900 + tm->tm_year, true);
1077 }
1078
1079 void talk_time(const struct tm *tm, bool enqueue)
1080 {
1081     if (global_settings.timeformat == 1)
1082     {
1083         /* Voice the hour */
1084         long am_pm_id = VOICE_AM;
1085         int hour = tm->tm_hour;
1086         if (hour >= 12)
1087         {
1088             am_pm_id = VOICE_PM;
1089             hour -= 12;
1090         }
1091         if (hour == 0)
1092             hour = 12;
1093         talk_number(hour, enqueue);
1094
1095         /* Voice the minutes */
1096         if (tm->tm_min == 0)
1097         {
1098             /* Say o'clock if the minute is 0. */
1099             talk_id(VOICE_OCLOCK, true);
1100         }
1101         else
1102         {
1103             /* Pronounce the leading 0 */
1104             if(tm->tm_min < 10)
1105                 talk_id(VOICE_OH, true);
1106             talk_number(tm->tm_min, true);
1107         }
1108         talk_id(am_pm_id, true);
1109     }
1110     else
1111     {
1112         /* Voice the time in 24 hour format */
1113         talk_number(tm->tm_hour, enqueue);
1114         if (tm->tm_min == 0)
1115         {
1116             talk_id(VOICE_HUNDRED, true);
1117             talk_id(VOICE_HOUR, true);
1118         }
1119         else
1120         {
1121             /* Pronounce the leading 0 */
1122             if(tm->tm_min < 10)
1123                 talk_id(VOICE_OH, true);
1124             talk_number(tm->tm_min, true);
1125         }
1126     }
1127 }
1128
1129 #endif