PageRenderTime 67ms CodeModel.GetById 18ms app.highlight 44ms RepoModel.GetById 1ms app.codeStats 0ms

/native/external/espeak/src/fifo.cpp

http://eyes-free.googlecode.com/
C++ | 593 lines | 400 code | 104 blank | 89 comment | 82 complexity | 72e363a29b06be6b4f40ca30462333cb MD5 | raw file
  1/***************************************************************************
  2 *   Copyright (C) 2007, Gilles Casse <gcasse@oralux.org>                  *
  3 *                                                                         *
  4 *   This program is free software; you can redistribute it and/or modify  *
  5 *   it under the terms of the GNU General Public License as published by  *
  6 *   the Free Software Foundation; either version 3 of the License, or     *
  7 *   (at your option) any later version.                                   *
  8 *                                                                         *
  9 *   This program is distributed in the hope that it will be useful,       *
 10 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 11 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 12 *   GNU General Public License for more details.                          *
 13 *                                                                         *
 14 *   You should have received a copy of the GNU General Public License     *
 15 *   along with this program; if not, write to the                         *
 16 *   Free Software Foundation, Inc.,                                       *
 17 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 18 ***************************************************************************/
 19#include "speech.h"
 20
 21#ifdef USE_ASYNC
 22// This source file is only used for asynchronious modes
 23
 24
 25//<includes
 26
 27#include <unistd.h>
 28#include <assert.h>
 29#include <string.h>
 30#include <stdlib.h>
 31#include <pthread.h>
 32#include <semaphore.h>
 33////#include <wchar.h>
 34#include <errno.h>
 35#include <sys/time.h>
 36#include <time.h>
 37
 38#include "fifo.h"
 39#include "wave.h"
 40#include "debug.h"
 41
 42
 43//>
 44//<decls and function prototypes
 45
 46// my_mutex: protects my_thread_is_talking, 
 47// my_stop_is_required, and the command fifo
 48static pthread_mutex_t my_mutex;
 49static int my_command_is_running = 0;
 50static int my_stop_is_required = 0;
 51// + fifo
 52//
 53
 54// my_thread: reads commands from the fifo, and runs them. 
 55static pthread_t my_thread;
 56static sem_t my_sem_start_is_required;
 57static sem_t my_sem_stop_is_acknowledged;
 58
 59static void* say_thread(void*);
 60
 61static espeak_ERROR push(t_espeak_command* the_command);
 62static t_espeak_command* pop();
 63static void init();
 64static int node_counter=0;
 65enum {MAX_NODE_COUNTER=400,
 66      INACTIVITY_TIMEOUT=50, // in ms, check that the stream is inactive
 67      MAX_INACTIVITY_CHECK=2
 68};
 69
 70//>
 71//<fifo_init
 72void fifo_init()
 73{
 74  ENTER("fifo_init");
 75
 76  // security
 77  pthread_mutex_init( &my_mutex, (const pthread_mutexattr_t *)NULL);
 78  init();
 79
 80  assert(-1 != sem_init(&my_sem_start_is_required, 0, 0));
 81  assert(-1 != sem_init(&my_sem_stop_is_acknowledged, 0, 0));
 82
 83  pthread_attr_t a_attrib;    
 84  if (pthread_attr_init (& a_attrib)
 85      || pthread_attr_setdetachstate(&a_attrib, PTHREAD_CREATE_JOINABLE)
 86      || pthread_create( &my_thread, 
 87			 & a_attrib, 
 88			 say_thread, 
 89			 (void*)NULL))
 90    {
 91      assert(0);
 92    }
 93
 94  pthread_attr_destroy(&a_attrib);
 95
 96  // leave once the thread is actually started
 97  SHOW_TIME("fifo > wait for my_sem_stop_is_acknowledged\n");
 98  while ((sem_wait(&my_sem_stop_is_acknowledged) == -1) && errno == EINTR)
 99    {
100      continue; // Restart when interrupted by handler
101    }
102  SHOW_TIME("fifo > get my_sem_stop_is_acknowledged\n");
103}
104//>
105//<fifo_add_command
106
107espeak_ERROR fifo_add_command (t_espeak_command* the_command)
108{
109  ENTER("fifo_add_command");
110	  
111  int a_status = pthread_mutex_lock(&my_mutex); 
112  espeak_ERROR a_error = EE_OK;
113
114  if (!a_status)
115    {
116      SHOW_TIME("fifo_add_command > locked\n");
117      a_error = push(the_command);
118      SHOW_TIME("fifo_add_command > unlocking\n");
119      a_status = pthread_mutex_unlock(&my_mutex);
120    }
121
122  if (!a_status && !my_command_is_running && (a_error == EE_OK))
123    {
124      // quit when command is actually started 
125      // (for possible forthcoming 'end of command' checks)
126      SHOW_TIME("fifo_add_command > post my_sem_start_is_required\n");
127      sem_post(&my_sem_start_is_required);
128      int val=1;
129      while (val)
130	{
131	  usleep(50000); // TBD: event?
132	  sem_getvalue(&my_sem_start_is_required, &val);
133	}
134    }
135
136  if (a_status != 0)
137    {
138      a_error = EE_INTERNAL_ERROR;
139    }
140
141  SHOW_TIME("LEAVE fifo_add_command");
142  return a_error;
143}
144
145//>
146//<fifo_add_commands
147
148espeak_ERROR fifo_add_commands (t_espeak_command* command1, t_espeak_command* command2)
149{
150  ENTER("fifo_add_command");
151	  
152  int a_status = pthread_mutex_lock(&my_mutex); 
153  espeak_ERROR a_error = EE_OK;
154
155  if (!a_status)
156    {
157      SHOW_TIME("fifo_add_commands > locked\n");
158
159      if (node_counter+1 >= MAX_NODE_COUNTER)
160	{
161	  SHOW("push > %s\n", "EE_BUFFER_FULL");
162	  a_error = EE_BUFFER_FULL;
163	}
164      else
165	{
166	  push(command1);
167	  push(command2);
168	}
169      SHOW_TIME("fifo_add_command > unlocking\n");
170      a_status = pthread_mutex_unlock(&my_mutex);
171    }
172
173  if (!a_status && !my_command_is_running && (a_error == EE_OK))
174    {
175      // quit when one command is actually started 
176      // (for possible forthcoming 'end of command' checks)
177      SHOW_TIME("fifo_add_command > post my_sem_start_is_required\n");
178      sem_post(&my_sem_start_is_required);
179      int val=1;
180      while (val)
181	{
182	  usleep(50000); // TBD: event?
183	  sem_getvalue(&my_sem_start_is_required, &val);
184	}
185    }
186
187  if (a_status != 0)
188    {
189      a_error = EE_INTERNAL_ERROR;
190    }
191
192  SHOW_TIME("LEAVE fifo_add_commands");
193  return a_error;
194}
195
196//>
197//<fifo_stop
198
199espeak_ERROR fifo_stop ()
200{
201  ENTER("fifo_stop");
202
203  int a_command_is_running = 0;
204  int a_status = pthread_mutex_lock(&my_mutex);
205  SHOW_TIME("fifo_stop > locked\n");
206  if (a_status != 0)
207    {
208      return EE_INTERNAL_ERROR;
209    }
210
211  if (my_command_is_running)
212    {
213      a_command_is_running = 1;
214      my_stop_is_required = 1;
215      SHOW_TIME("fifo_stop > my_stop_is_required = 1\n");
216    }
217  SHOW_TIME("fifo_stop > unlocking\n");
218  a_status = pthread_mutex_unlock(&my_mutex);
219  if (a_status != 0)
220    {
221      return EE_INTERNAL_ERROR;
222    }
223
224  if (a_command_is_running)
225    {
226      SHOW_TIME("fifo_stop > wait for my_sem_stop_is_acknowledged\n");
227      while ((sem_wait(&my_sem_stop_is_acknowledged) == -1) && errno == EINTR)
228	{
229	  continue; // Restart when interrupted by handler
230	}
231      SHOW_TIME("fifo_stop > get my_sem_stop_is_acknowledged\n");
232    }
233
234  SHOW_TIME("fifo_stop > my_stop_is_required = 0\n");
235  my_stop_is_required = 0;
236  SHOW_TIME("LEAVE fifo_stop\n");
237
238  return EE_OK;
239}
240
241//>
242
243//<fifo_is_speaking
244int fifo_is_busy ()
245{
246  //  ENTER("isSpeaking");
247  //  int aResult = (int) (my_command_is_running || WaveIsPlaying());
248  SHOW("fifo_is_busy > aResult = %d\n",my_command_is_running);
249  return my_command_is_running;
250}
251
252// int pause ()
253// {
254//   ENTER("pause");
255//   // TBD
256//   //   if (espeakPause (espeakHandle, 1))
257//   return true;
258// }
259
260// int resume ()
261// {
262//   ENTER("resume");
263//   // TBD
264//   //   if (espeakPause (espeakHandle, 0))
265//   return true;
266// }
267//>
268
269
270//<sleep_until_start_request_or_inactivity
271
272int sleep_until_start_request_or_inactivity()
273{
274  SHOW_TIME("fifo > sleep_until_start_request_or_inactivity > ENTER");
275  int a_start_is_required=0;
276
277  // Wait for the start request (my_sem_start_is_required).
278  // Besides this, if the audio stream is still busy, 
279  // check from time to time its end. 
280  // The end of the stream is confirmed by several checks 
281  // for filtering underflow.
282  //
283  int i=0;
284  while((i<= MAX_INACTIVITY_CHECK) && !a_start_is_required)
285    {
286      if (wave_is_busy( NULL) )
287	{
288	  i = 0;
289	}
290      else
291	{
292	  i++;
293	}
294
295      int err=0;
296      struct timespec ts, to;
297      struct timeval tv;
298      
299      clock_gettime2( &ts);
300      to.tv_sec = ts.tv_sec;
301      to.tv_nsec = ts.tv_nsec;
302      
303      add_time_in_ms( &ts, INACTIVITY_TIMEOUT);
304      
305      SHOW("fifo > sleep_until_start_request_or_inactivity > start sem_timedwait (start_is_required) from %d.%09lu to %d.%09lu \n", 
306	   to.tv_sec, to.tv_nsec,
307	   ts.tv_sec, ts.tv_nsec);
308      
309      while ((err = sem_timedwait(&my_sem_start_is_required, &ts)) == -1 
310	     && errno == EINTR)
311	{
312	      continue;
313	}
314      
315      assert (gettimeofday(&tv, NULL) != -1);
316      SHOW("fifo > sleep_until_start_request_or_inactivity > stop sem_timedwait (start_is_required, err=%d) %d.%09lu \n", err, 
317	   tv.tv_sec, tv.tv_usec*1000);
318      
319      if (err==0)
320	{
321	  a_start_is_required = 1;
322	}
323    }
324  SHOW_TIME("fifo > sleep_until_start_request_or_inactivity > LEAVE");
325  return a_start_is_required;
326}
327
328//>
329//<close_stream
330
331static void close_stream()
332{
333  SHOW_TIME("fifo > close_stream > ENTER\n");
334
335  // Warning: a wave_close can be already required by 
336  // an external command (espeak_Cancel + fifo_stop), if so: 
337  // my_stop_is_required = 1;
338
339  int a_status = pthread_mutex_lock(&my_mutex);
340  assert (!a_status);
341  int a_stop_is_required = my_stop_is_required;
342  if (!a_stop_is_required)
343    {
344      my_command_is_running = 1;
345    }
346  a_status = pthread_mutex_unlock(&my_mutex);
347
348  if (!a_stop_is_required)
349    {
350      wave_close(NULL);
351
352      int a_status = pthread_mutex_lock(&my_mutex);
353      assert (!a_status);
354      my_command_is_running = 0;
355
356      a_stop_is_required = my_stop_is_required;
357      a_status = pthread_mutex_unlock(&my_mutex);
358      
359      if (a_stop_is_required)
360	{
361	  // acknowledge the stop request
362	  SHOW_TIME("fifo > close_stream > post my_sem_stop_is_acknowledged\n");
363	  int a_status = sem_post(&my_sem_stop_is_acknowledged);
364	  assert( a_status != -1);
365	}
366    }
367
368  SHOW_TIME("fifo > close_stream > LEAVE\n");
369}
370
371//>
372//<say_thread
373
374static void* say_thread(void*)
375{
376  ENTER("say_thread");
377
378  SHOW_TIME("say_thread > post my_sem_stop_is_acknowledged\n");
379
380  // announce that thread is started
381  sem_post(&my_sem_stop_is_acknowledged);
382
383  int look_for_inactivity=0;
384
385  while(1)
386    {
387      SHOW_TIME("say_thread > wait for my_sem_start_is_required\n");
388
389      int a_start_is_required = 0;
390      if (look_for_inactivity)
391	{
392	  a_start_is_required = sleep_until_start_request_or_inactivity();
393	  if (!a_start_is_required)
394	    {
395	      close_stream();
396	    }
397	}
398      look_for_inactivity = 1;
399
400      if (!a_start_is_required)
401	{
402	  while ((sem_wait(&my_sem_start_is_required) == -1) && errno == EINTR)
403	    {
404	      continue; // Restart when interrupted by handler
405	    }
406	}
407      SHOW_TIME("say_thread > get my_sem_start_is_required\n");
408
409      SHOW_TIME("say_thread > my_command_is_running = 1\n");
410      my_command_is_running = 1;
411
412      while( my_command_is_running)
413	{
414	  SHOW_TIME("say_thread > locking\n");
415	  int a_status = pthread_mutex_lock(&my_mutex);
416	  assert (!a_status);
417	  t_espeak_command* a_command = (t_espeak_command*)pop();
418
419	  if (a_command == NULL)
420	    {
421	      SHOW_TIME("say_thread > text empty (talking=0) \n");
422	      a_status = pthread_mutex_unlock(&my_mutex);
423	      SHOW_TIME("say_thread > unlocked\n");
424	      SHOW_TIME("say_thread > my_command_is_running = 0\n");
425	      my_command_is_running = 0;
426	    }
427	  else
428	    {
429	      display_espeak_command(a_command);
430	      // purge start semaphore
431	      SHOW_TIME("say_thread > purge my_sem_start_is_required\n");
432	      while(0 == sem_trywait(&my_sem_start_is_required))
433		{
434		};
435
436	      if (my_stop_is_required)
437		{ 
438		  SHOW_TIME("say_thread > my_command_is_running = 0\n");
439		  my_command_is_running = 0;
440		}
441	      SHOW_TIME("say_thread > unlocking\n");
442	      a_status = pthread_mutex_unlock(&my_mutex);
443
444	      if (my_command_is_running)
445		{
446		  process_espeak_command(a_command);
447		}
448	      delete_espeak_command(a_command);
449	    }
450	}
451
452      if (my_stop_is_required)
453	{ 
454	  // no mutex required since the stop command is synchronous
455	  // and waiting for my_sem_stop_is_acknowledged
456	  init();
457
458	  // purge start semaphore
459	  SHOW_TIME("say_thread > purge my_sem_start_is_required\n");
460	  while(0==sem_trywait(&my_sem_start_is_required))
461	    {
462	    };
463	  
464	  // acknowledge the stop request
465	  SHOW_TIME("say_thread > post my_sem_stop_is_acknowledged\n");
466	  int a_status = sem_post(&my_sem_stop_is_acknowledged);
467	  assert( a_status != -1);
468	}
469      // and wait for the next start
470      SHOW_TIME("say_thread > wait for my_sem_start_is_required\n");      
471    }
472    
473  return NULL;
474}
475
476int fifo_is_command_enabled()
477{
478  SHOW("ENTER fifo_is_command_enabled=%d\n",(int)(0 == my_stop_is_required));
479  return (0 == my_stop_is_required);
480}
481
482//>
483//<fifo
484typedef struct t_node
485{
486  t_espeak_command* data;
487  t_node *next;
488} node;
489
490static node* head=NULL;
491static node* tail=NULL;
492// return 1 if ok, 0 otherwise
493static espeak_ERROR push(t_espeak_command* the_command)
494{
495  ENTER("fifo > push");
496
497  assert((!head && !tail) || (head && tail));
498
499  if (the_command == NULL)
500    {
501      SHOW("push > command=0x%x\n", NULL);
502      return EE_INTERNAL_ERROR;
503    }
504
505  if (node_counter >= MAX_NODE_COUNTER)
506    {
507      SHOW("push > %s\n", "EE_BUFFER_FULL");
508      return EE_BUFFER_FULL;
509    }
510
511  node *n = (node *)malloc(sizeof(node));
512  if (n == NULL)
513    {
514      return EE_INTERNAL_ERROR;
515    }
516  
517  if (head == NULL)
518    {
519      head = n;
520      tail = n;
521    }
522  else
523    {
524      tail->next = n;
525      tail = n;
526    }
527  
528  tail->next = NULL;
529  tail->data = the_command;
530
531  node_counter++;
532  SHOW("push > counter=%d\n",node_counter);
533
534  the_command->state = CS_PENDING;
535  display_espeak_command(the_command);
536
537  return EE_OK;
538}
539
540static t_espeak_command* pop()
541{
542  ENTER("fifo > pop");
543  t_espeak_command* the_command = NULL;
544
545  assert((!head && !tail) || (head && tail));
546
547  if (head != NULL)
548    {
549      node* n = head;
550      the_command = n->data;
551      head = n->next;
552      free(n);
553      node_counter--;
554      SHOW("pop > command=0x%x (counter=%d)\n",the_command, node_counter);
555    }
556
557  if(head == NULL)
558    {
559      tail = NULL;
560    }
561
562  display_espeak_command(the_command);
563 
564  return the_command;
565}
566
567
568static void init()
569{
570  ENTER("fifo > init");
571  while (delete_espeak_command( pop() ))
572    {}
573  node_counter = 0;
574}
575
576//>
577//<fifo_init
578void fifo_terminate()
579{
580  ENTER("fifo_terminate");
581
582  pthread_cancel(my_thread);
583  pthread_join(my_thread,NULL);
584  pthread_mutex_destroy(&my_mutex);
585  sem_destroy(&my_sem_start_is_required);
586  sem_destroy(&my_sem_stop_is_acknowledged);
587
588  init(); // purge fifo
589}
590
591#endif
592//>
593