opalmixer.h

Go to the documentation of this file.

/*
 * opalmixer.h
 *
 * OPAL media mixers
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * Copyright (C) 2007 Post Increment
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): Craig Southeren (craigs@postincrement.com)
 *                 Robert Jongbloed (robertj@voxlucida.com.au)
 *
 * $Revision: 23052 $
 * $Author: rjongbloed $
 * $Date: 2009-07-03 13:57:32 +0000 (Fri, 03 Jul 2009) $
 */


#ifndef OPAL_OPAL_OPALMIXER_H
#define OPAL_OPAL_OPALMIXER_H

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <opal/buildopts.h>

#include <queue>

#include <opal/localep.h>
#include <codec/vidcodec.h>


class RTP_DataFrame;
class OpalJitterBuffer;


//#define OPAL_MIXER_AUDIO_DEBUG 1



class OpalBaseMixer
{
  public:
    OpalBaseMixer(
      bool pushThread,    
      unsigned periodMS,  
      unsigned periodTS   
    );

    virtual ~OpalBaseMixer();

    typedef PString Key_T;

    virtual bool AddStream(
      const Key_T & key   
    );

    virtual void RemoveStream(
      const Key_T & key   
    );

    virtual void RemoveAllStreams();

    virtual bool WriteStream(
      const Key_T & key,          
      const RTP_DataFrame & input 
    );

    virtual RTP_DataFrame * ReadMixed();
    virtual bool ReadMixed(RTP_DataFrame & mixed);

    virtual bool OnMixed(
      RTP_DataFrame * & mixed   
    );

    void StartPushThread();

    void StopPushThread(bool lock = true);

    unsigned GetPeriodTS() const { return m_periodTS; }

  protected:
    struct Stream {
      virtual ~Stream() { }
      virtual void QueuePacket(const RTP_DataFrame & rtp) = 0;
      queue<RTP_DataFrame> m_queue;
    };
    typedef std::map<Key_T, Stream *> StreamMap_T;

    virtual Stream * CreateStream() = 0;
    virtual bool MixStreams(RTP_DataFrame & frame) = 0;
    virtual size_t GetOutputSize() const = 0;

    virtual bool OnPush();
    void PushThreadMain();

    bool      m_pushThread;      // true if to use a thread to push data out
    unsigned  m_periodMS;        // Mixing interval in milliseconds
    unsigned  m_periodTS;        // Mixing interval in timestamp units

    StreamMap_T     m_inputStreams;     // Map of key to stream for input RTP frame queues
    unsigned        m_outputTimestamp;  // RTP timestamp for output data
    RTP_DataFrame * m_pushFrame;        // Cached frame for pushing RTP
    PThread *       m_workerThread;     // reader thread handle
    bool            m_threadRunning;    // used to stop reader thread
    PMutex          m_mutex;            // mutex for list of streams and thread handle
};


class OpalAudioMixer : public OpalBaseMixer
{
  public:
    OpalAudioMixer(
      bool stereo = false,    
      unsigned sampleRate = OpalMediaFormat::AudioClockRate, 
      bool pushThread = true, 
      unsigned period = 10    
    );

    ~OpalAudioMixer() { StopPushThread(); }

    virtual void RemoveStream(
      const Key_T & key   
    );

    virtual void RemoveAllStreams();

    bool IsStereo() const { return m_stereo; }

    unsigned GetSampleRate() const { return m_sampleRate; }

    bool SetSampleRate(
      unsigned rate   
    );

    bool SetJitterBufferSize(
      const Key_T & key,       
      unsigned minJitterDelay, 
      unsigned maxJitterDelay  
    );

  protected:
    struct AudioStream : public Stream
    {
      AudioStream(OpalAudioMixer & mixer);
      ~AudioStream();

      virtual void QueuePacket(const RTP_DataFrame & rtp);
      const short * GetAudioDataPtr();

      OpalAudioMixer   & m_mixer;
      OpalJitterBuffer * m_jitter;
      unsigned           m_nextTimestamp;
      PShortArray        m_cacheSamples;
      size_t             m_samplesUsed;
    };

    virtual Stream * CreateStream();
    virtual bool MixStreams(RTP_DataFrame & frame);
    virtual size_t GetOutputSize() const;

    void PreMixStreams();
    void MixStereo(RTP_DataFrame & frame);
    void MixAdditive(RTP_DataFrame & frame, const short * audioToSubtract);

  protected:
    bool     m_stereo;
    unsigned m_sampleRate;

    AudioStream    * m_left;
    AudioStream    * m_right;
    std::vector<int> m_mixedAudio;
};



#if OPAL_VIDEO

class OpalVideoMixer : public OpalBaseMixer
{
  public:
    enum Styles {
      eSideBySideLetterbox, 
      eSideBySideScaled,    
      eStackedPillarbox,    
      eStackedScaled,       
      eGrid,                
    };

    OpalVideoMixer(
      Styles style,           
      unsigned width,         
      unsigned height,        
      unsigned rate = 15,     
      bool pushThread = true  
    );

    ~OpalVideoMixer() { StopPushThread(); }

    unsigned GetFrameWidth() const { return m_width; }

    unsigned GetFrameHeight() const { return m_height; }

    unsigned GetFrameRate() const { return 1000/m_periodMS; }

    bool SetFrameRate(
      unsigned rate   // New frames per second.
    );

    bool SetFrameSize(
      unsigned width,   
      unsigned height   
    );

  protected:
    struct VideoStream : public Stream
    {
      VideoStream(OpalVideoMixer & mixer);
      virtual void QueuePacket(const RTP_DataFrame & rtp);
      void InsertVideoFrame(unsigned x, unsigned y, unsigned w, unsigned h);

      OpalVideoMixer     & m_mixer;
    };

    friend struct VideoStream;

    virtual Stream * CreateStream();
    virtual bool MixStreams(RTP_DataFrame & frame);
    virtual size_t GetOutputSize() const;

  protected:
    Styles     m_style;
    unsigned   m_width, m_height;

    PBYTEArray m_frameStore;
};

#endif // OPAL_VIDEO



class OpalMixerConnection;
class OpalMixerNode;


struct OpalMixerNodeInfo
{
  OpalMixerNodeInfo()
    : m_listenOnly(false)
    , m_sampleRate(OpalMediaFormat::AudioClockRate)
#if OPAL_VIDEO
    , m_audioOnly(false)
    , m_style(OpalVideoMixer::eGrid)
    , m_width(PVideoFrameInfo::CIFWidth)
    , m_height(PVideoFrameInfo::CIFHeight)
    , m_rate(15)
#endif
  { }

  virtual ~OpalMixerNodeInfo() { }

  virtual OpalMixerNodeInfo * Clone() const { return new OpalMixerNodeInfo(*this); }

  PString  m_name;
  bool     m_listenOnly;
  unsigned m_sampleRate;
#if OPAL_VIDEO
  bool     m_audioOnly;
  OpalVideoMixer::Styles m_style;
  unsigned m_width;
  unsigned m_height;
  unsigned m_rate;
#endif
};


class OpalMixerEndPoint : public OpalLocalEndPoint
{
    PCLASSINFO(OpalMixerEndPoint, OpalLocalEndPoint);
  public:
    OpalMixerEndPoint(
      OpalManager & manager,  
      const char * prefix     
    );

    ~OpalMixerEndPoint();

    virtual void ShutDown();

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual PSafePtr<OpalConnection> MakeConnection(
      OpalCall & call,           
      const PString & party,     
      void * userData = NULL,    
      unsigned int options = 0,  
      OpalConnection::StringOptions * stringOptions  = NULL
    );

    virtual PBoolean GarbageCollection();

    PSafePtr<OpalMixerConnection> GetMixerConnectionWithLock(
      const PString & token,     
      PSafetyMode mode = PSafeReadWrite
    ) { return GetConnectionWithLockAs<OpalMixerConnection>(token, mode); }

    virtual OpalMixerConnection * CreateConnection(
      PSafePtr<OpalMixerNode> node, 
      OpalCall & call,              
      void * userData,              
      unsigned options,
      OpalConnection::StringOptions * stringOptions
    );

    PSafePtr<OpalMixerNode> AddNode(
      OpalMixerNodeInfo * info 
    );

    virtual OpalMixerNode * CreateNode(
      OpalMixerNodeInfo * info 
    );

    PSafePtr<OpalMixerNode> GetFirstNode(
      PSafetyMode mode = PSafeReference 
    ) const { return PSafePtr<OpalMixerNode>(m_nodesByUID, mode); }

    PSafePtr<OpalMixerNode> FindNode(
      const PString & name,             
      PSafetyMode mode = PSafeReference 
    );

    void RemoveNode(
      OpalMixerNode & node 
    );

    void SetAdHocNodeInfo(
      const OpalMixerNodeInfo & info
    );
    void SetAdHocNodeInfo(
      OpalMixerNodeInfo * info
    );

    OpalMixerNodeInfo * GetAdHocNodeInfo() { return m_adHocNodeInfo; }

  protected:
    OpalMixerNodeInfo * m_adHocNodeInfo;

    PSafeDictionary<PGloballyUniqueID, OpalMixerNode> m_nodesByUID;
    PDictionary<PString, OpalMixerNode>               m_nodesByName;

  friend class OpalMixerNode;
};



class OpalMixerConnection : public OpalLocalConnection
{
    PCLASSINFO(OpalMixerConnection, OpalLocalConnection);
  public:
    OpalMixerConnection(
      PSafePtr<OpalMixerNode> node, 
      OpalCall & call,              
      OpalMixerEndPoint & endpoint, 
      void * userData,              
      unsigned options,
      OpalConnection::StringOptions * stringOptions
    );

    ~OpalMixerConnection();

    virtual void OnReleased();

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual OpalMediaStream * CreateMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource                    
    );

    virtual void ApplyStringOptions(OpalConnection::StringOptions & stringOptions);

    void SetListenOnly(
      bool listenOnly   
    );

    bool GetListenOnly() const { return m_listenOnly; }

    PSafePtr<OpalMixerNode> GetNode() const { return m_node; }

  protected:
    OpalMixerEndPoint     & m_endpoint;
    PSafePtr<OpalMixerNode> m_node;
    bool                    m_listenOnly;
};


class OpalMixerMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalMixerMediaStream, OpalMediaStream);
  public:
    OpalMixerMediaStream(
      OpalMixerConnection & conn,          
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      PSafePtr<OpalMixerNode> node,        
      bool listenOnly                      
    );

    ~OpalMixerMediaStream();

    virtual PBoolean Open();

    virtual PBoolean Close();

    virtual PBoolean WritePacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean RequiresPatchThread(
      OpalMediaStream * sinkStream  
    ) const;

    PSafePtr<OpalMixerNode> GetNode() { return m_node; }

  protected:
    PSafePtr<OpalMixerNode> m_node;
#if OPAL_VIDEO
    bool m_video;
#endif
};


class OpalMixerNode : public PSafeObject
{
    PCLASSINFO(OpalMixerNode, PSafeObject);
  public:
    OpalMixerNode(
      OpalMixerEndPoint & endpoint,   
      OpalMixerNodeInfo * info        
    );

    ~OpalMixerNode();

    void ShutDown();

    void PrintOn(
      ostream & strm    
    ) const;

    void AttachConnection(
      OpalMixerConnection * connection  
    );

    void DetachConnection(
      OpalMixerConnection * connection  
    );

    bool AttachStream(
      OpalMixerMediaStream * stream     
    );

    void DetachStream(
      OpalMixerMediaStream * stream     
    );

    bool WriteAudio(
      const OpalBaseMixer::Key_T & key, 
      const RTP_DataFrame & input       
    ) { return m_audioMixer.WriteStream(key, input); }

#if OPAL_VIDEO

    bool WriteVideo(
      const OpalBaseMixer::Key_T & key, 
      const RTP_DataFrame & input       
    ) { return m_videoMixer.WriteStream(key, input); }
#endif // OPAL_VIDEO


    const PGloballyUniqueID & GetGUID() const { return m_guid; }

    const PStringList & GetNames() const { return m_names; }

    void AddName(
      const PString & name
    );

    void RemoveName(
      const PString & name
    );

    PINDEX GetConnectionCount() const { return m_connections.GetSize(); }

    PSafePtr<OpalMixerConnection> GetFirstConnection(
      PSafetyMode mode = PSafeReference
    ) const { return PSafePtr<OpalMixerConnection>(m_connections, mode); }

    const OpalMixerNodeInfo & GetNodeInfo() { return *m_info; }

    const PTime & GetCreationTime() const { return m_creationTime; }

  protected:
    OpalMixerEndPoint & m_endpoint;
    PGloballyUniqueID   m_guid;
    PStringList         m_names;
    OpalMixerNodeInfo * m_info;
    PTime               m_creationTime;

    PSafeList<OpalMixerConnection> m_connections;

    struct MediaMixer
    {
      MediaMixer();

      PSafeList<OpalMixerMediaStream> m_outputStreams;
    };

    struct AudioMixer : public OpalAudioMixer, public MediaMixer
    {
      AudioMixer(const OpalMixerNodeInfo & info);
      ~AudioMixer();

      virtual bool OnPush();

      struct CachedAudio {
        CachedAudio();
        ~CachedAudio();
        enum { Collecting, Collected, Completed } m_state;
        RTP_DataFrame    m_raw;
        RTP_DataFrame    m_encoded;
        OpalTranscoder * m_transcoder;
      };
      std::map<PString, CachedAudio> m_cache;

      void PushOne(
        OpalMixerMediaStream & stream,
        CachedAudio & cache,
        const short * audioToSubtract
      );
#ifdef OPAL_MIXER_AUDIO_DEBUG
      class PAudioMixerDebug * m_audioDebug;
#endif
    };
    AudioMixer m_audioMixer;

#if OPAL_VIDEO
    struct VideoMixer : public OpalVideoMixer, public MediaMixer
    {
      VideoMixer(const OpalMixerNodeInfo & info);
      ~VideoMixer();

      virtual bool OnMixed(RTP_DataFrame * & output);

      PDictionary<OpalMediaFormat, OpalTranscoder> m_transcoders;
    };
    VideoMixer m_videoMixer;
#endif // OPAL_VIDEO
};


#endif // OPAL_OPAL_OPAL_MIXER

---