libjulius/src/adin-cut.c

Go to the documentation of this file.

/*
 * Copyright (c) 1991-2007 Kawahara Lab., Kyoto University
 * Copyright (c) 2000-2005 Shikano Lab., Nara Institute of Science and Technology
 * Copyright (c) 2005-2007 Julius project team, Nagoya Institute of Technology
 * All rights reserved
 */

#include <julius/julius.h>
#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif

#undef THREAD_DEBUG
#define TMP_FIX_200602          

void
adin_setup_param(ADIn *adin, Jconf *jconf)
{
  float samples_in_msec;
  int freq;

  if (jconf->detect.silence_cut < 2) {
    adin->adin_cut_on = (jconf->detect.silence_cut == 1) ? TRUE : FALSE;
  } else {
    adin->adin_cut_on = adin->silence_cut_default;
  }
  adin->strip_flag = jconf->preprocess.strip_zero_sample;
  adin->thres = jconf->detect.level_thres;
#ifdef HAVE_PTHREAD
  if (jconf->input.speech_input == SP_MIC && jconf->decodeopt.segment) {
    adin->ignore_speech_while_recog = FALSE;
  } else {
    adin->ignore_speech_while_recog = TRUE;
  }
#endif
  adin->need_zmean = jconf->preprocess.use_zmean;
  /* calc & set internal parameter from configuration */
  freq = jconf->input.sfreq;
  samples_in_msec = (float) freq / (float)1000.0;
  /* cycle buffer length = head margin length */
  adin->c_length = (int)((float)jconf->detect.head_margin_msec * samples_in_msec);      /* in msec. */
  /* compute zerocross trigger count threshold in the cycle buffer */
  adin->noise_zerocross = jconf->detect.zero_cross_num * adin->c_length / freq;
  /* variables that comes from the tail margin length (in wstep) */
  adin->nc_max = (int)((float)(jconf->detect.tail_margin_msec * samples_in_msec / (float)DEFAULT_WSTEP)) + 2;
  adin->sbsize = jconf->detect.tail_margin_msec * samples_in_msec + (adin->c_length * jconf->detect.zero_cross_num / 200);
  adin->c_offset = 0;

#ifdef HAVE_PTHREAD
  adin->transfer_online = FALSE;
  adin->speech = NULL;
#endif
  adin->ds = NULL;

  /**********************/
  /* initialize buffers */
  /**********************/
  adin->buffer = (SP16 *)mymalloc(sizeof(SP16) * MAXSPEECHLEN);
  adin->cbuf = (SP16 *)mymalloc(sizeof(SP16) * adin->c_length);
  adin->swapbuf = (SP16 *)mymalloc(sizeof(SP16) * adin->sbsize);
  if (adin->down_sample) {
    adin->io_rate = 3;          /* 48 / 16 (fixed) */
    adin->buffer48 = (SP16 *)mymalloc(sizeof(SP16) * MAXSPEECHLEN * adin->io_rate);
  }
  if (adin->adin_cut_on) {
    init_count_zc_e(&(adin->zc), adin->c_length);
  }
  
  adin->need_init = TRUE;

  adin->rehash = FALSE;

}

static void
adin_purge(ADIn *a, int from)
{
  if (from > 0 && a->current_len - from > 0) {
    memmove(a->buffer, &(a->buffer[from]), (a->current_len - from) * sizeof(SP16));
  }
  a->bp = a->current_len - from;
}

static int
adin_cut(int (*ad_process)(SP16 *, int, Recog *), int (*ad_check)(Recog *), Recog *recog)
{
  ADIn *a;
  static int i;
  int ad_process_ret;
  int imax, len, cnt;
  int wstep;
  static int end_status;        /* return value */
  static boolean transfer_online_local; /* local repository of transfer_online */
  static int zc;                /* count of zero cross */

  a = recog->adin;

  /*
   * there are 3 buffers:
   *   temporary storage queue: buffer[]
   *   cycle buffer for zero-cross counting: (in zc_e)
   *   swap buffer for re-starting after short tail silence
   *
   * Each samples are first read to buffer[], then passed to count_zc_e()
   * to find trigger.  Samples between trigger and end of speech are 
   * passed to (*ad_process) with pointer to the first sample and its length.
   *
   */

  if (a->need_init) {
    a->bpmax = MAXSPEECHLEN;
    a->bp = 0;
    a->is_valid_data = FALSE;
    /* reset zero-cross status */
    if (a->adin_cut_on) {
      reset_count_zc_e(&(a->zc), a->thres, a->c_length, a->c_offset);
    }
    a->end_of_stream = FALSE;
    a->nc = 0;
    a->sblen = 0;
    a->need_init = FALSE;               /* for next call */
  }

  /****************/
  /* resume input */
  /****************/
  /* restart speech input if paused on the last call */
  if (a->ad_resume != NULL) {
    if ((*(a->ad_resume))() == FALSE)  return(-1);
  }

  if (!a->adin_cut_on && a->is_valid_data == TRUE) {
#ifdef HAVE_PTHREAD
    if (!a->enable_thread) callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#else
    callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#endif
  }

  /*************/
  /* main loop */
  /*************/
  for (;;) {

    /****************************/
    /* read in new speech input */
    /****************************/
    if (a->end_of_stream) {
      /* already reaches end of stream, just process the rest */
      a->current_len = a->bp;
    } else {
      /*****************************************************/
      /* get samples from input device to temporary buffer */
      /*****************************************************/
      /* buffer[0..bp] is the current remaining samples */
      /*
        mic input - samples exist in a device buffer
        tcpip input - samples exist in a socket
        file input - samples in a file
           
        Return value is the number of read samples.
        If no data exists in the device (in case of mic input), ad_read()
        will return 0.  If reached end of stream (in case end of file or
        receive end ack from tcpip client), it will return -1.
        If error, returns -2.
      */
      if (a->down_sample) {
        /* get 48kHz samples to temporal buffer */
        cnt = (*(a->ad_read))(a->buffer48, (a->bpmax - a->bp) * a->io_rate);
      } else {
        cnt = (*(a->ad_read))(&(a->buffer[a->bp]), a->bpmax - a->bp);
      }
      if (cnt < 0) {            /* end of stream / segment or error */
        /* set the end status */
        if (cnt == -2) end_status = -1; /* end by error */
        else if (cnt == -1) end_status = 0; /* end by normal end of stream */
        /* now the input has been ended, 
           we should not get further speech input in the next loop, 
           instead just process the samples in the temporary buffer until
           the entire data is processed. */
        a->end_of_stream = TRUE;                
        cnt = 0;                        /* no new input */
        /* in case the first trial of ad_read() fails, exit this loop */
        if (a->bp == 0) break;
      }
      if (a->down_sample && cnt != 0) {
        /* convert to 16kHz  */
        cnt = ds48to16(&(a->buffer[a->bp]), a->buffer48, cnt, a->bpmax - a->bp, a->ds);
        if (cnt < 0) {          /* conversion error */
          jlog("ERROR: adin_cut: error in down sampling\n");
          end_status = -1;
          a->end_of_stream = TRUE;
          cnt = 0;
          if (a->bp == 0) break;
        }
      }

      /*************************************************/
      /* execute callback here for incoming raw data stream.*/
      /* the content of buffer[bp...bp+cnt-1] or the   */
      /* length can be modified in the functions.      */
      /*************************************************/
      if (cnt > 0) {
        callback_exec_adin(CALLBACK_ADIN_CAPTURED, recog, &(a->buffer[a->bp]), cnt);
      }

      /*************************************************/
      /* some speech processing for the incoming input */
      /*************************************************/
      if (cnt > 0) {
        if (a->strip_flag) {
          /* strip off successive zero samples */
          len = strip_zero(&(a->buffer[a->bp]), cnt);
          if (len != cnt) cnt = len;
        }
        if (a->need_zmean) {
          /* remove DC offset */
          sub_zmean(&(a->buffer[a->bp]), cnt);
        }
      }
      
      /* current len = current samples in buffer */
      a->current_len = a->bp + cnt;
    }
#ifdef THREAD_DEBUG
    if (a->end_of_stream) {
      jlog("DEBUG: adin_cut: stream already ended\n");
    }
    if (cnt > 0) {
      jlog("DEBUG: adin_cut: get %d samples [%d-%d]\n", a->current_len - a->bp, a->bp, a->current_len);
    }
#endif

    /**************************************************/
    /* call the periodic callback (non threaded mode) */
    /*************************************************/
    /* this function is mainly for periodic checking of incoming command
       in module mode */
    /* in threaded mode, this will be done in process thread, not here in adin thread */
    if (ad_check != NULL
#ifdef HAVE_PTHREAD
        && !a->enable_thread
#endif
        ) {
      /* if ad_check() returns value < 0, termination of speech input is required */
      if ((i = (*ad_check)(recog)) < 0) { /* -1: soft termination -2: hard termination */
        //      if ((i == -1 && current_len == 0) || i == -2) {
        if (i == -2 ||
            (i == -1 && a->adin_cut_on && a->is_valid_data == FALSE) ||
            (i == -1 && !a->adin_cut_on && a->current_len == 0)) {
          end_status = -2;      /* recognition terminated by outer function */
          goto break_input;
        }
      }
    }

    /***********************************************************************/
    /* if no data has got but not end of stream, repeat next input samples */
    /***********************************************************************/
    if (a->current_len == 0) continue;

    /* When not adin_cut mode, all incoming data is valid.
       So is_valid_data should be set to TRUE when some input first comes
       till this input ends.  So, if some data comes, set is_valid_data to
       TRUE here. */ 
    if (!a->adin_cut_on && a->is_valid_data == FALSE && a->current_len > 0) {
      a->is_valid_data = TRUE;
#ifdef HAVE_PTHREAD
      if (!a->enable_thread) callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#else
      callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#endif
    }

    /******************************************************/
    /* prepare for processing samples in temporary buffer */
    /******************************************************/
    
    wstep = DEFAULT_WSTEP;      /* process unit (should be smaller than cycle buffer) */

    /* imax: total length that should be processed at one ad_read() call */
    /* if in real-time mode and not threaded, recognition process 
       will be called and executed as the ad_process() callback within
       this function.  If the recognition speed is over the real time,
       processing all the input samples at the loop below may result in the
       significant delay of getting next input, that may result in the buffer
       overflow of the device (namely a microphone device will suffer from
       this). So, in non-threaded mode, in order to avoid buffer overflow and
       input frame dropping, we will leave here by processing 
       only one segment [0..wstep], and leave the rest in the temporary buffer.
    */
#ifdef HAVE_PTHREAD
    if (a->enable_thread) imax = a->current_len; /* process whole */
    else imax = (a->current_len < wstep) ? a->current_len : wstep; /* one step */
#else
    imax = (a->current_len < wstep) ? a->current_len : wstep;   /* one step */
#endif
    
    /* wstep: unit length for the loop below */
    if (wstep > a->current_len) wstep = a->current_len;

#ifdef THREAD_DEBUG
    jlog("DEBUG: process %d samples by %d step\n", imax, wstep);
#endif

#ifdef HAVE_PTHREAD
    if (a->enable_thread) {
      /* get transfer status to local */
      pthread_mutex_lock(&(a->mutex));
      transfer_online_local = a->transfer_online;
      pthread_mutex_unlock(&(a->mutex));
    }
#endif

    /*********************************************************/
    /* start processing buffer[0..current_len] by wstep step */
    /*********************************************************/
    i = 0;
    while (i + wstep <= imax) {
      
      if (a->adin_cut_on) {

        /********************/
        /* check triggering */
        /********************/
        /* the cycle buffer in count_zc_e() holds the last
           samples of (head_margin) miliseconds, and the zerocross
           over the threshold level are counted within the cycle buffer */
        
        /* store the new data to cycle buffer and update the count */
        /* return zero-cross num in the cycle buffer */
        zc = count_zc_e(&(a->zc), &(a->buffer[i]), wstep);
        
        if (zc > a->noise_zerocross) { /* now triggering */
          
          if (a->is_valid_data == FALSE) {
            /*****************************************************/
            /* process off, trigger on: detect speech triggering */
            /*****************************************************/
            
            a->is_valid_data = TRUE;   /* start processing */
            a->nc = 0;
#ifdef THREAD_DEBUG
            jlog("DEBUG: detect on\n");
#endif
#ifdef HAVE_PTHREAD
            if (!a->enable_thread) callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#else
            callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
#endif

            /****************************************/
            /* flush samples stored in cycle buffer */
            /****************************************/
            /* (last (head_margin) msec samples */
            /* if threaded mode, processing means storing them to speech[].
               if ignore_speech_while_recog is on (default), ignore the data
               if transfer is offline (=while processing second pass).
               Else, datas are stored even if transfer is offline */
            if ( ad_process != NULL
#ifdef HAVE_PTHREAD
                 && (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
                 ) {
              /* copy content of cycle buffer to cbuf */
              zc_copy_buffer(&(a->zc), a->cbuf, &len);
              /* Note that the last 'wstep' samples are the same as
                 the current samples 'buffer[i..i+wstep]', and
                 they will be processed later.  So, here only the samples
                 cbuf[0...len-wstep] will be processed
              */
              if (len - wstep > 0) {
#ifdef THREAD_DEBUG
                jlog("DEBUG: callback for buffered samples (%d bytes)\n", len - wstep);
#endif
#ifdef HAVE_PTHREAD
                if (!a->enable_thread) callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->cbuf, len - wstep);
#else
                callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->cbuf, len - wstep);
#endif
                ad_process_ret = (*ad_process)(a->cbuf, len - wstep, recog);
                switch(ad_process_ret) {
                case 1:         /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
                  if (a->enable_thread) {
                    /* in threaded mode, just stop transfer */
                    pthread_mutex_lock(&(a->mutex));
                    a->transfer_online = transfer_online_local = FALSE;
                    pthread_mutex_unlock(&(a->mutex));
                  } else {
                    /* in non-threaded mode, set end status and exit loop */
                    end_status = 2;
                    adin_purge(a, i);
                    goto break_input;
                  }
                  break;
#else
                  /* in non-threaded mode, set end status and exit loop */
                  end_status = 2;
                  adin_purge(a, i);
                  goto break_input;
#endif
                case -1:                /* error occured in callback */
                  /* set end status and exit loop */
                  end_status = -1;
                  goto break_input;
                }
              }
            }
            
          } else {              /* is_valid_data == TRUE */
            /******************************************************/
            /* process on, trigger on: we are in a speech segment */
            /******************************************************/
            
            if (a->nc > 0) {
              
              /*************************************/
              /* re-triggering in trailing silence */
              /*************************************/
              
#ifdef THREAD_DEBUG
              jlog("DEBUG: re-triggered\n");
#endif
              /* reset noise counter */
              a->nc = 0;

#ifdef TMP_FIX_200602
              if (ad_process != NULL
#ifdef HAVE_PTHREAD
                  && (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
                  ) {
#endif
              
              /*************************************************/
              /* process swap buffer stored while tail silence */
              /*************************************************/
              /* In trailing silence, the samples within the tail margin length
                 will be processed immediately, but samples after the tail
                 margin will not be processed, instead stored in swapbuf[].
                 If re-triggering occurs while in the trailing silence,
                 the swapped samples should be processed now to catch up
                 with current input
              */
              if (a->sblen > 0) {
#ifdef THREAD_DEBUG
                jlog("DEBUG: callback for swapped %d samples\n", a->sblen);
#endif
#ifdef HAVE_PTHREAD
                if (!a->enable_thread) callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->swapbuf, a->sblen);
#else
                callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->swapbuf, a->sblen);
#endif
                ad_process_ret = (*ad_process)(a->swapbuf, a->sblen, recog);
                a->sblen = 0;
                switch(ad_process_ret) {
                case 1:         /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
                  if (a->enable_thread) {
                    /* in threaded mode, just stop transfer */
                    pthread_mutex_lock(&(a->mutex));
                    a->transfer_online = transfer_online_local = FALSE;
                    pthread_mutex_unlock(&(a->mutex));
                  } else {
                    /* in non-threaded mode, set end status and exit loop */
                    end_status = 2;
                    adin_purge(a, i);
                    goto break_input;
                  }
                  break;
#else
                  /* in non-threaded mode, set end status and exit loop */
                  end_status = 2;
                  adin_purge(a, i);
                  goto break_input;
#endif
                case -1:                /* error occured in callback */
                  /* set end status and exit loop */
                  end_status = -1;
                  goto break_input;
                }
              }
#ifdef TMP_FIX_200602
              }
#endif
            }
          } 
        } else if (a->is_valid_data == TRUE) {
          
          /*******************************************************/
          /* process on, trigger off: processing tailing silence */
          /*******************************************************/
          
#ifdef THREAD_DEBUG
          jlog("DEBUG: TRAILING SILENCE\n");
#endif
          if (a->nc == 0) {
            /* start of tail silence: prepare valiables for start swapbuf[] */
            a->rest_tail = a->sbsize - a->c_length;
            a->sblen = 0;
#ifdef THREAD_DEBUG
            jlog("DEBUG: start tail silence, rest_tail = %d\n", a->rest_tail);
#endif
          }

          /* increment noise counter */
          a->nc++;
        }
      } /* end of triggering handlers */
      
      
      /********************************************************************/
      /* process the current segment buffer[i...i+wstep] if process == on */
      /********************************************************************/
      
      if (a->adin_cut_on && a->is_valid_data && a->nc > 0 && a->rest_tail == 0) {
        
        /* The current trailing silence is now longer than the user-
           specified tail margin length, so the current samples
           should not be processed now.  But if 're-triggering'
           occurs in the trailing silence later, they should be processed
           then.  So we just store the overed samples in swapbuf[] and
           not process them now */
        
#ifdef THREAD_DEBUG
        jlog("DEBUG: tail silence over, store to swap buffer (nc=%d, rest_tail=%d, sblen=%d-%d)\n", a->nc, a->rest_tail, a->sblen, a->sblen+wstep);
#endif
        if (a->sblen + wstep > a->sbsize) {
          jlog("ERROR: adin_cut: swap buffer for re-triggering overflow\n");
        }
        memcpy(&(a->swapbuf[a->sblen]), &(a->buffer[i]), wstep * sizeof(SP16));
        a->sblen += wstep;
        
      } else {

        /* we are in a normal speech segment (nc == 0), or
           trailing silence (shorter than tail margin length) (nc>0,rest_tail>0)
           The current trailing silence is shorter than the user-
           specified tail margin length, so the current samples
           should be processed now as same as the normal speech segment */
        
#ifdef TMP_FIX_200602
        if (!a->adin_cut_on || a->is_valid_data == TRUE) {
#else
        if(
           (!a->adin_cut_on || a->is_valid_data == TRUE)
#ifdef HAVE_PTHREAD
           && (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
           ) {
#endif
          if (a->nc > 0) {
            /* if we are in a trailing silence, decrease the counter to detect
             start of swapbuf[] above */
            if (a->rest_tail < wstep) a->rest_tail = 0;
            else a->rest_tail -= wstep;
#ifdef THREAD_DEBUG
            jlog("DEBUG: %d processed, rest_tail=%d\n", wstep, a->rest_tail);
#endif
          }
#ifdef TMP_FIX_200602
          if (ad_process != NULL
#ifdef HAVE_PTHREAD
              && (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
              ) {

#else
          if ( ad_process != NULL ) {
#endif
#ifdef THREAD_DEBUG
            jlog("DEBUG: callback for input sample [%d-%d]\n", i, i+wstep);
#endif
            /* call external function */
#ifdef HAVE_PTHREAD
            if (!a->enable_thread) callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, &(a->buffer[i]), wstep);
#else
            callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, &(a->buffer[i]), wstep);
#endif
            ad_process_ret = (*ad_process)(&(a->buffer[i]), wstep, recog);
            switch(ad_process_ret) {
            case 1:             /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
              if (a->enable_thread) {
                /* in threaded mode, just stop transfer */
                pthread_mutex_lock(&(a->mutex));
                a->transfer_online = transfer_online_local = FALSE;
                pthread_mutex_unlock(&(a->mutex));
              } else {
                /* in non-threaded mode, set end status and exit loop */
                adin_purge(a, i+wstep);
                end_status = 2;
                goto break_input;
              }
              break;
#else
              /* in non-threaded mode, set end status and exit loop */
              adin_purge(a, i+wstep);
              end_status = 2;
              goto break_input;
#endif
            case -1:            /* error occured in callback */
              /* set end status and exit loop */
              end_status = -1;
              goto break_input;
            }
          }
        }
      } /* end of current segment processing */

      
      if (a->adin_cut_on && a->is_valid_data && a->nc >= a->nc_max) {
        /*************************************/
        /* process on, trailing silence over */
        /* = end of input segment            */
        /*************************************/
#ifdef THREAD_DEBUG
        jlog("DEBUG: detect off\n");
#endif
        /* end input by silence */
        a->is_valid_data = FALSE;       /* turn off processing */
        a->sblen = 0;
#ifdef HAVE_PTHREAD
        if (a->enable_thread) { /* just stop transfer */
          pthread_mutex_lock(&(a->mutex));
          a->transfer_online = transfer_online_local = FALSE;
          pthread_mutex_unlock(&(a->mutex));
        } else {
          adin_purge(a, i+wstep);
          end_status = 1;
          goto break_input;
        }
#else
        adin_purge(a, i+wstep);
        end_status = 1;
        goto break_input;
#endif
      }

      /*********************************************************/
      /* end of processing buffer[0..current_len] by wstep step */
      /*********************************************************/
      i += wstep;               /* increment to next wstep samples */
    }
    
    /* purge processed samples and update queue */
    adin_purge(a, i);

    /* end of input by end of stream */
    if (a->end_of_stream && a->bp == 0) break;
  }

break_input:

  /****************/
  /* pause input */
  /****************/
  /* stop speech input */
  if (a->ad_pause != NULL) {
    if ((*(a->ad_pause))() == FALSE) {
      jlog("ERROR: adin_cut: failed to pause recording\n");
      end_status = -1;
    }
  }

  /* execute callback */
#ifdef HAVE_PTHREAD
  if (!a->enable_thread) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
#else
  callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
#endif

  if (a->end_of_stream) {                       /* input already ends */
    if (a->bp == 0) {           /* rest buffer successfully flushed */
      /* reset status */
      a->need_init = TRUE;              /* bufer status shoule be reset at next call */
    }
    end_status = (a->bp) ? 1 : 0;
  }
  
  return(end_status);
}

#ifdef HAVE_PTHREAD
/***********************/
/* threading functions */
/***********************/

/*************************/
/* adin thread functions */
/*************************/

static int
adin_store_buffer(SP16 *now, int len, Recog *recog)
{
  ADIn *a;

  a = recog->adin;
  if (a->speechlen + len > MAXSPEECHLEN) {
    /* just mark as overflowed, and continue this thread */
    pthread_mutex_lock(&(a->mutex));
    a->adinthread_buffer_overflowed = TRUE;
    pthread_mutex_unlock(&(a->mutex));
    return(0);
  }
  pthread_mutex_lock(&(a->mutex));
  memcpy(&(a->speech[a->speechlen]), now, len * sizeof(SP16));
  a->speechlen += len;
  pthread_mutex_unlock(&(a->mutex));
#ifdef THREAD_DEBUG
  jlog("DEBUG: input: stored %d samples, total=%d\n", len, a->speechlen);
#endif

  return(0);                    /* continue */
}

static void
adin_thread_input_main(void *dummy)
{
  Recog *recog;

  recog = dummy;

  adin_cut(adin_store_buffer, NULL, recog);
}

boolean
adin_thread_create(Recog *recog)
{
  pthread_t adin_thread;        
  ADIn *a;

  a = recog->adin;

  /* init storing buffer */
  a->speech = (SP16 *)mymalloc(sizeof(SP16) * MAXSPEECHLEN);
  a->speechlen = 0;

  a->transfer_online = FALSE; /* tell adin-mic thread to wait at initial */
  a->adinthread_buffer_overflowed = FALSE;

  if (pthread_mutex_init(&(a->mutex), NULL) != 0) { /* error */
    jlog("ERROR: adin_thread_create: failed to initialize mutex\n");
    return FALSE;
  }
  if (pthread_create(&adin_thread, NULL, (void *)adin_thread_input_main, recog) != 0) {
    jlog("ERROR: adin_thread_create: failed to create AD-in thread\n");
    return FALSE;
  }
  if (pthread_detach(adin_thread) != 0) { /* not join, run forever */
    jlog("ERROR: adin_thread_create: failed to detach AD-in thread\n");
    return FALSE;
  }
  jlog("STAT: AD-in thread created\n");
  return TRUE;
}

/****************************/
/* process thread functions */
/****************************/

static int
adin_thread_process(int (*ad_process)(SP16 *, int, Recog *), int (*ad_check)(Recog *), Recog *recog)
{
  int prev_len, nowlen;
  int ad_process_ret;
  int i;
  boolean overflowed_p;
  boolean transfer_online_local;
  boolean first_trig;
  ADIn *a;

  a = recog->adin;

  /* reset storing buffer --- input while recognition will be ignored */
  pthread_mutex_lock(&(a->mutex));
  /*if (speechlen == 0) transfer_online = TRUE;*/ /* tell adin-mic thread to start recording */
  a->transfer_online = TRUE;
#ifdef THREAD_DEBUG
  jlog("DEBUG: process: reset, speechlen = %d, online=%d\n", a->speechlen, a->transfer_online);
#endif
  pthread_mutex_unlock(&(a->mutex));

  /* main processing loop */
  prev_len = 0;
  first_trig = TRUE;
  for(;;) {
    /* get current length (locking) */
    pthread_mutex_lock(&(a->mutex));
    nowlen = a->speechlen;
    overflowed_p = a->adinthread_buffer_overflowed;
    transfer_online_local = a->transfer_online;
    pthread_mutex_unlock(&(a->mutex));
    /* check if other input thread has overflowed */
    if (overflowed_p) {
      jlog("WARNING: adin_thread_process: too long input (> %d samples), segmented now\n", MAXSPEECHLEN);
      /* segment input here */
      pthread_mutex_lock(&(a->mutex));
      a->adinthread_buffer_overflowed = FALSE;
      a->speechlen = 0;
      a->transfer_online = transfer_online_local = FALSE;
      pthread_mutex_unlock(&(a->mutex));
      if (!first_trig) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
      return(1);                /* return with segmented status */
    }
    /* callback poll */
    if (ad_check != NULL) {
      if ((i = (*(ad_check))(recog)) < 0) {
        if ((i == -1 && nowlen == 0) || i == -2) {
          pthread_mutex_lock(&(a->mutex));
          a->transfer_online = transfer_online_local = FALSE;
          a->speechlen = 0;
          pthread_mutex_unlock(&(a->mutex));
          if (!first_trig) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
          return(-2);
        }
      }
    }
    if (prev_len < nowlen) {
#ifdef THREAD_DEBUG
      jlog("DEBUG: process: proceed [%d-%d]\n",prev_len, nowlen);
#endif
      /* got new sample, process */
      /* As the speech[] buffer is monotonously increase,
         content of speech buffer [prev_len..nowlen] would not alter
         in both threads
         So locking is not needed while processing.
       */
      /*jlog("DEBUG: main: read %d-%d\n", prev_len, nowlen);*/
      /* call on/off callback */
      if (first_trig) {
        first_trig = FALSE;
        callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
      }
      if (ad_process != NULL) {
        callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, &(a->speech[prev_len]), nowlen - prev_len);
        ad_process_ret = (*ad_process)(&(a->speech[prev_len]), nowlen - prev_len, recog);
#ifdef THREAD_DEBUG
        jlog("DEBUG: ad_process_ret=%d\n", ad_process_ret);
#endif
        switch(ad_process_ret) {
        case 1:                 /* segmented */
          /* segmented by callback function */
          /* purge processed samples and keep transfering */
          pthread_mutex_lock(&(a->mutex));
          if(a->speechlen > nowlen) {
            memmove(a->speech, &(a->speech[nowlen]), (a->speechlen - nowlen) * sizeof(SP16));
            a->speechlen -= nowlen;
          } else {
            a->speechlen = 0;
          }
          a->transfer_online = transfer_online_local = FALSE;
          pthread_mutex_unlock(&(a->mutex));
          if (!first_trig) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
          /* keep transfering */
          return(2);            /* return with segmented status */
        case -1:                /* error */
          pthread_mutex_lock(&(a->mutex));
          a->transfer_online = transfer_online_local = FALSE;
          pthread_mutex_unlock(&(a->mutex));
          if (!first_trig) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
          return(-1);           /* return with error */
        }
      }
      if (a->rehash) {
        /* rehash */
        pthread_mutex_lock(&(a->mutex));
        if (debug2_flag) jlog("STAT: adin_cut: rehash from %d to %d\n", a->speechlen, a->speechlen - prev_len);
        a->speechlen -= prev_len;
        nowlen -= prev_len;
        memmove(a->speech, &(a->speech[prev_len]), a->speechlen * sizeof(SP16));
        pthread_mutex_unlock(&(a->mutex));
        a->rehash = FALSE;
      }
      prev_len = nowlen;
    } else {
      if (transfer_online_local == FALSE) {
        /* segmented by zero-cross */
        /* reset storing buffer for next input */
        pthread_mutex_lock(&(a->mutex));
        a->speechlen = 0;
        pthread_mutex_unlock(&(a->mutex));
        if (!first_trig) callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
        break;
      }
      usleep(50000);   /* wait = 0.05sec*/            
    }
  }

  /* as threading assumes infinite input */
  /* return value should be 1 (segmented) */
  return(1);
}
#endif /* HAVE_PTHREAD */




int
adin_go(int (*ad_process)(SP16 *, int, Recog *), int (*ad_check)(Recog *), Recog *recog)
{
#ifdef HAVE_PTHREAD
  if (recog->adin->enable_thread) {
    return(adin_thread_process(ad_process, ad_check, recog));
  }
#endif
  return(adin_cut(ad_process, ad_check, recog));
}

boolean
adin_standby(ADIn *a, int freq, void *arg)
{
  if (a->need_zmean) zmean_reset();
  if (a->ad_standby != NULL) return(a->ad_standby(freq, arg));
  return TRUE;
}
boolean
adin_begin(ADIn *a)
{
  if (a->need_zmean) zmean_reset();
  if (a->ad_begin != NULL) return(a->ad_begin());
  return TRUE;
}
boolean
adin_end(ADIn *a)
{
  if (a->ad_end != NULL) return(a->ad_end());
  return TRUE;
}

void
adin_free_param(Recog *recog)
{
  ADIn *a;

  a = recog->adin;

  if (a->ds) {
    ds48to16_free(a->ds);
    a->ds = NULL;
  }
  if (a->adin_cut_on) {
    free_count_zc_e(&(a->zc));
  }
  if (a->down_sample) {
    free(a->buffer48);
  }
  free(a->swapbuf);
  free(a->cbuf);
  free(a->buffer);
#ifdef HAVE_PTHREAD
  if (a->speech) free(a->speech);
#endif
}

/* end of file */

---