ArSoundsQueue.h

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481

*/

/*  $Id: ArSoundsQueue.h,v 1.23 2005/08/04 21:21:06 lafary Exp $

    This file is part of Aria, (C) Copyright 2004, ActivMedia Robotics
    <http://www.activmedia.com>

    Aria is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Foobar is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this software; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef ARSOUNDSQUEUE_H
#define ARSOUNDSQUEUE_H


#include "ariaTypedefs.h"
#include "ArASyncTask.h"
#include "ArCondition.h"
#include "ArSpeech.h"
#include <list>
#include <string>
#include <set>

class ArSoundsQueue: public ArASyncTask
{
public:

  enum ItemType { SPEECH, SOUND_FILE, SOUND_DATA, OTHER };

  typedef ArRetFunctor2<bool, const char*, const char*> PlayItemFunctor;
  typedef ArFunctor InterruptItemFunctor;

  class Item {
  public:
    std::string data;
    ItemType type;
    std::string params;
    int priority;
    std::list<InterruptItemFunctor*> interruptCallbacks;
    std::list<PlayItemFunctor*> playCallbacks;

    Item();
    Item(std::string _data, ItemType _type, std::string _params, int priority);
    Item(std::string _data, ItemType _type, std::string _params, int priority, std::list<PlayItemFunctor*> callbacks); 

    Item(const Item& toCopy);

    bool operator==(const Item& other) const
    {
      return (other.type == type && other.params == params && other.data == data);
    }

    void play();

    void interrupt();
  };


  ArSoundsQueue();

  ArSoundsQueue(ArRetFunctor<bool> *speakInitCB, 
                    PlayItemFunctor *speakCB = 0, 
        InterruptItemFunctor *interruptSpeechCB = 0,
                    ArRetFunctor<bool> *playInitCB = 0, 
                    PlayItemFunctor *playFileCB = 0,
        InterruptItemFunctor *interruptFileCB = 0);

  ArSoundsQueue(ArSpeechSynth* speechSynthesizer, 
                    ArRetFunctor<bool> *playInitCB = 0, 
                    PlayItemFunctor *playFileCB = 0,
        InterruptItemFunctor *interruptFileCB = 0);

  virtual ~ArSoundsQueue();

  void addInitCallback(ArRetFunctor<bool> *cb) {
    myInitCallbacks.push_back(cb);
  }

  void setSpeakInitCallback(ArRetFunctor<bool> *cb) {
    addInitCallback(cb);
  }

  void addItem(ArSoundsQueue::Item item);

  void addItem(ItemType type, const char* data, std::list<PlayItemFunctor*> callbacks, int priority = 0, const char* params = 0);

  bool isInitialized()
  {
    return myInitialized;
  }

  bool isSpeakingOrPlaying(void) { return (myPlayingSomething); }

  bool isPlaying() { return myPlayingSomething; }


  bool isSpeaking() { return myPlayingSomething; }


  void run(void) { runInThisThread(); }

  void runAsync(void) { create(false); }

  void pause();

  void resume() ;

  bool isPaused();

  void interrupt();

  void clearQueue();

  void stop() ;

  ArFunctor* getPauseCallback() 
  {
    return new ArFunctorC<ArSoundsQueue>(this, &ArSoundsQueue::pause);
  }

  ArFunctor* getResumeCallback() 
  {
    return new ArFunctorC<ArSoundsQueue>(this, &ArSoundsQueue::resume);
  }


  size_t getCurrentQueueSize()
  {
    size_t size;
    lock();
    size = myQueue.size();
    unlock();
    return size;
  }

  void addSoundStartedCallback(ArFunctor* f)
  {
    myStartPlaybackCBList.push_back(f);
  }

  void remSoundStartedCallback(ArFunctor* f)
  {
    myStartPlaybackCBList.remove(f);
  }

  void addSoundFinishedCallback(ArFunctor* f)
  {
    myEndPlaybackCBList.push_back(f);
  }

  void remSoundFinishedCallback(ArFunctor* f)
  {
    myEndPlaybackCBList.remove(f);
  }

  void addQueueNonemptyCallback(ArFunctor* f)
  {
    myQueueNonemptyCallbacks.push_back(f);
  }

  void remQueueNonemptyCallback(ArFunctor* f)
  {
    myQueueNonemptyCallbacks.remove(f);
  }

  void addQueueEmptyCallback(ArFunctor* f)
  {
    myQueueEmptyCallbacks.push_back(f);
  }

  void remQueueEmptyCallback(ArFunctor* f)
  {
    myQueueEmptyCallbacks.remove(f);
  }

  
  std::set<int> findPendingItems(const char* item);

  void removePendingItems(const char* item, ItemType type);

  void removePendingItems(const char* data);

  void removePendingItems(int priority);

  void removePendingItems(int priority, ItemType type);

  void removePendingItems(ItemType type);

  std::string nextItem(ItemType type);
  std::string nextItem(int priority);
  std::string nextItem(ItemType type, int priority);


  
  void setSpeakCallback(PlayItemFunctor *cb) {
    myDefaultSpeakCB = cb;
  }

  void setInterruptSpeechCallback(InterruptItemFunctor *cb) {
    myDefaultInterruptSpeechCB = cb;
  }

  void setPlayFileCallback(PlayItemFunctor *cb) {
    myDefaultPlayFileCB = cb;
  }

  void setPlayWavFileCallback(PlayItemFunctor* cb) {
    setPlayFileCallback(cb);
  }

  void setInterruptFileCallback(InterruptItemFunctor *cb) {
    myDefaultInterruptFileCB = cb;
  }

  void setInterruptWavFileCallback(InterruptItemFunctor* cb) {
    setInterruptFileCallback(cb);
  }

  void speak(const char *fmt, ...);

  void speakWithVoice(const char* voice, const char* fmt, ...);

  void speakWithPriority(int priority, const char* fmt, ...);

  void play(const char *filename_fmt, ...);

#ifndef SWIG

  ArSoundsQueue::Item createDefaultSpeechItem(const char* speech = 0);

  ArSoundsQueue::Item createDefaultFileItem(const char* filename = 0);
#endif // SWIG
  
  virtual void *runThread(void *arg);

protected:
  bool myInitialized;
  std::list<Item> myQueue;
  ArMutex myQueueMutex;
  void lock() {
    myQueueMutex.lock();
  }
  void unlock() {
    myQueueMutex.unlock();
  }
  bool tryLock() {
    return myQueueMutex.tryLock();
  }

  std::list< ArRetFunctor<bool>* > myInitCallbacks;

  bool myPlayingSomething;
  Item myLastItem; 


  PlayItemFunctor *myDefaultSpeakCB;
  InterruptItemFunctor *myDefaultInterruptSpeechCB;
  PlayItemFunctor *myDefaultPlayFileCB;
  InterruptItemFunctor *myDefaultInterruptFileCB;
 
  int myPauseRequestCount;  
  ArCondition myPausedCondition;    


  std::list<ArFunctor*> myStartPlaybackCBList;
  std::list<ArFunctor*> myEndPlaybackCBList;
  std::list<ArFunctor*> myQueueNonemptyCallbacks;
  std::list<ArFunctor*> myQueueEmptyCallbacks;

  void invokeCallbacks(const std::list<ArFunctor*>& lst);

  void invokeCallbacks(const std::list<ArRetFunctor<bool>*>& lst);

  void pushQueueItem(Item item);
  void pushQueueItem_NoLock(Item item);

  Item popQueueItem();
  Item popQueueItem_NoLock();

};

#endif

---