main.h

mcu for video conference test

    virtual void AwaitTermination();

    // delegate functions
    void AddMember   (MyH323Connection * conn);
    void RemoveMember(MyH323Connection * conn);

    // new functions
    BOOL ReadAudio(const PString & token, void * buffer, PINDEX amount, PString roomID);
    BOOL WriteAudio(const PString & token, const void * buffer, PINDEX amount, PString roomID);
#ifndef NO_VIDEO
		BOOL DetectNoise(const void * buffer, PINDEX amount);

    BOOL ReadVideo(const PString & token, void * buffer, PINDEX amount, PString roomID);
    BOOL WriteVideo(const PString & token, const void * buffer, PINDEX amount, PString roomID);

    PINDEX FindTokensVideoPosn(const PString & thisToken, PString roomID);
    BOOL AddVideoPosnToken(const PString & thisToken, PString roomID);
    
    void EnableVideoReception(BOOL isOK)
          {   hasVideo = isOK;  }
#endif

    void HandleUserInterface();    

#ifndef NO_VIDEO
    int        videoTxQuality, videoFramesPS, videoFill;
    BOOL       videoLarge; 
#endif

    void       SetDefaultRoomName(PString roomName);
    PString    GetDefaultRoomName(void);

    PString    audioLoopbackRoom;
    BOOL       hasMenu;

  protected:
    PMutex memberMutex;   // Prevents multiple tasks simultaneously using 
                          // list of connected nodes.
    StringListDict memberListDict;
    
    AudioDelay  writeDelay;

#ifndef NO_VIDEO
    BOOL        hasVideo;

    StringListDict spokenListDict; //Array of 'spoken lists' used to decide the
                                   //4 user images to display (one list room)
    VideoBufferDict videoBufferDict; //Array of VideoBuffers,(one for each room)
    StringListDict  videoPosnDict;   //Array of 'position lists' that describe
                                     //where video is displayed in the buffer.

#endif

    PSyncPoint exitFlag;
    PString    defaultRoomName;
};


class OutgoingAudio : public PChannel
{
  PCLASSINFO(OutgoingAudio, PChannel);

  public:
    OutgoingAudio(MyH323EndPoint & ep, MyH323Connection & conn);
    
    BOOL Read(void * buffer, PINDEX amount);
    BOOL Close();

  protected:
    void CreateSilence(void * buffer, PINDEX amount);

    MyH323EndPoint & ep;
    MyH323Connection & conn;

    AudioDelay delay;
    PMutex audioChanMutex;
};

class IncomingAudio : public PChannel
{
  PCLASSINFO(IncomingAudio, PChannel);

  public:
    IncomingAudio(MyH323EndPoint & ep, MyH323Connection & conn);

    BOOL Write(const void * buffer, PINDEX amount);
    BOOL Close();

  protected:
    MyH323EndPoint & ep;
    MyH323Connection & conn;
    PMutex audioChanMutex;
    AudioDelay delay;
};

////////////////////////////////////////////////////
/** OutGoingVideo describes the data leaving the computer,
    and then sent by TCP/IP methods to the remote computer.


    OutGoingVideo is the connection/channel which connects the
    codec and the connection class, for the transport of data.
     */
#ifndef NO_VIDEO
class OutgoingVideo : public PVideoChannel
{
  PCLASSINFO(OutgoingVideo, PVideoChannel);

  public:
    OutgoingVideo(MyH323EndPoint & ep, MyH323Connection & conn, int framesPerSec, BOOL videoLarge);

    ~OutgoingVideo();

    BOOL Close();
    
    /** uses over ride of Read function in the PChannel class.
      */
    BOOL Read(void * buffer, PINDEX  amount);
    
    void SetRenderFrameSize(int /*_width*/, int /*_height*/) 
      {PTRACE(3,"OutgoingVideo Set size");}
    
    BOOL Redraw(const BYTE * /*frame*/) 
        { return TRUE; }

    BOOL IsOpen() const   
        { return !closed; }

    BOOL IsGrabberOpen()
        { return TRUE; }


    PINDEX  GetGrabWidth()
        { return (videoLarge ? 352 : 176); }

    /**Return the height of the currently selected grabbing device.
     */
    PINDEX  GetGrabHeight()
      { return (videoLarge ? 288 : 144 ); }


    protected:

    MyH323EndPoint & ep;
    MyH323Connection & conn;

    PMutex videoChanMutex;
    BOOL videoLarge;

    AudioDelay delay;
    int        msBetweenFrames;
    BOOL       closed;
};

////////////////////////////////////////////////////
/** IncomingVideo describes the data entering the computer,
    which is placed in the video buffer.

     */
class IncomingVideo : public PVideoChannel
{
  PCLASSINFO(IncomingVideo, PVideoChannel);

  public:
    IncomingVideo(MyH323EndPoint & ep, MyH323Connection & conn);

    ~IncomingVideo();
    
    BOOL Write(const void * buffer, PINDEX amount);
    BOOL Close();

    void SetRenderFrameSize(int _width, int _height);

    BOOL Redraw(const BYTE * frame) 
        { return Write(frame,0); }

    BOOL IsOpen() const   
        { return !closed; }

    PINDEX  GetGrabWidth()
        { PTRACE(3,"incomingvideo get grab width"); return width; }

    /**Return the height of the currently selected grabbing device.
     */
    PINDEX  GetGrabHeight()
      { return height; }

    protected:

    MyH323EndPoint & ep;
    MyH323Connection & conn;
    PMutex videoChanMutex;

    PINDEX  width;
    PINDEX  height;
    PINDEX  frameSize;

    AudioDelay delay;
    BOOL       closed;
};

#endif //NO_VIDEO



class MyH323Connection : public H323Connection
{
  PCLASSINFO(MyH323Connection, H323Connection);

  public:
    MyH323Connection(MyH323EndPoint &, unsigned);
    ~MyH323Connection();

    // overrides from H323Connection
    BOOL OpenAudioChannel(BOOL, unsigned,   H323AudioCodec & codec);
		void CleanUpOnCallEnd();
#ifndef NO_VIDEO
    BOOL OpenVideoChannel( BOOL isEncoding, H323VideoCodec & codec);
#endif

    AnswerCallResponse OnAnswerCall(const PString &, const H323SignalPDU &, H323SignalPDU &);
    BOOL OnSendSignalSetup( H323SignalPDU & callProceedingPDU );
    BOOL OnStartLogicalChannel(H323Channel & channel);

    // functions to add and remove audio buffers
    void AddMember   (const PString & token);
    void RemoveMember(const PString & token);

    // functions called for incoming and outgoing channels.
    // These provide a link between the audio/video channels and the endpoint.
    BOOL OnIncomingAudio(const void * buffer, PINDEX amount);
    BOOL OnOutgoingAudio(void * buffer, PINDEX amount);
#ifndef NO_VIDEO
    BOOL OnIncomingVideo(const void * buffer, PINDEX amount);
    BOOL OnOutgoingVideo(void * buffer, PINDEX & amount);
#endif

    // functions called to put data in/out of the buffer array.
    BOOL ReadAudio(const PString & token, void * buffer, PINDEX amount);
    BOOL WriteAudio(const PString & token, const void * buffer, PINDEX amount);

#ifndef NO_VIDEO
    void EnableVideoReception(BOOL isOK) { hasVideo = isOK;  }
    PString GetVideoTransmitCodecName() const { return videoTransmitCodecName; }
    PString GetVideoReceiveCodecName() const  { return videoReceiveCodecName; }
#endif

    PString GetRoomID() const            { return roomID; }
    PString GetAudioTransmitCodecName() const { return audioTransmitCodecName; }
    PString GetAudioReceiveCodecName() const  { return audioReceiveCodecName; }

  protected:
    MyH323EndPoint & ep;
    PString audioTransmitCodecName, audioReceiveCodecName;

    PMutex  audioMutex;
    AudioBufferDict audioBuffers;

    IncomingAudio * incomingAudio;
    OutgoingAudio * outgoingAudio;

    PMutex  videoMutex;

    BOOL          connected;

#ifndef NO_VIDEO
    PString videoTransmitCodecName, videoReceiveCodecName;
    BOOL          hasVideo;
    IncomingVideo * incomingVideo;
    OutgoingVideo * outgoingVideo;
#endif

    PString roomID;
    BOOL aborted;
};


////////////////////////////////////////////////////

class UserInterfaceThread : public PThread
{
    PCLASSINFO(UserInterfaceThread, PThread);
  public:
    UserInterfaceThread(MyH323EndPoint & end)
      : PThread(1000, NoAutoDeleteThread), endpoint(end) { Resume(); }
    void Main()
      { endpoint.HandleUserInterface(); }
  protected:
    MyH323EndPoint & endpoint;
};

#endif  


// End of File ///////////////////////////////////////////////////////////////