MpBuf.h

Go to the documentation of this file.

//  
// Copyright (C) 2006-2012 SIPez LLC.  All rights reserved.
//  
//  
// $$ 

#ifndef _INCLUDED_MPBUF_H // [
#define _INCLUDED_MPBUF_H

// SYSTEM INCLUDES
#include <stdlib.h>
#include <assert.h>

// APPLICATION INCLUDES
#include "mp/MpBufPool.h"

// DEFINES
// MACROS
// Uncomment MPBUF_DEBUG define to enable deep MpBuf debug with a lot of
// messages and more asserts.
//#define MPBUF_DEBUG

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// FORWARD DECLARATIONS
class MpFlowGraphBase;

// CONSTANTS
// STRUCTS


typedef enum {
    MP_BUF,               
      MP_BUF_ARRAY,       
      MP_BUF_ARRAY_END,   
      MP_BUF_DATA,        
        MP_BUF_AUDIO,     
        MP_BUF_AUDIO_END, 
        MP_BUF_VIDEO,     
        MP_BUF_VIDEO_END, 
        MP_BUF_UDP,       
          MP_BUF_RTP,     
          MP_BUF_RTP_END, 
        MP_BUF_UDP_END,   
      MP_BUF_DATA_END,    
    MP_BUF_END            
} MP_BUFFERS_TREE;

// TYPEDEFS


struct MpBuf {
    friend class MpBufPtr;
    friend class MpBufPool;

/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:
/* ============================ CREATORS ================================== */




/* ============================ MANIPULATORS ============================== */


    void attach();

    void detach();


/* ============================ ACCESSORS ================================= */


    void setFlowGraph(MpFlowGraphBase* flowgraph)
    {
        mpFlowGraph = flowgraph;
    };

    MP_BUFFERS_TREE getType() const {return mType;};

    MpBufPool *getBufferPool() const {return mpPool;};


/* ============================ INQUIRY =================================== */



/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

    MP_BUFFERS_TREE mType;     
    int mRefCounter;           
    MpBufPool* mpPool;         
    MpFlowGraphBase* mpFlowGraph; 
    void (*mpDestroy)(MpBuf*); 
    void (*mpInitClone)(MpBuf*); 

    static void sInitClone(MpBuf *pBuffer);

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

    MpBuf(const MpBuf &);
    MpBuf &operator=(const MpBuf &);
};


class MpBufPtr {
    friend class MpBufPool;

/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

/* ============================ CREATORS ================================== */


    MpBufPtr()
        : mpBuffer(NULL)
    {};


    MpBufPtr(MpBuf *buffer)
        : mpBuffer(buffer)
    {
        if (mpBuffer != NULL) {
            mpBuffer->mType = MP_BUF;
            mpBuffer->mpDestroy = NULL;
            mpBuffer->mpInitClone = MpBuf::sInitClone;
            mpBuffer->attach();
        }
#ifdef _DEBUG
        else {
            osPrintf("mpBuffer == NULL!\n");
        }
#endif
    };

    ~MpBufPtr()
    {
        if (mpBuffer != NULL)
            mpBuffer->detach();
    };

    MpBufPtr(const MpBufPtr &buffer) 
        : mpBuffer(buffer.mpBuffer)
    {
        if (mpBuffer != NULL)
            mpBuffer->attach();
    }

    MpBufPtr clone() const
    {
       MpBufPtr clone;

       // Return invalid pointer as a copy of invalid pointer.
       if (!isValid())
          return clone;

       // Get fresh buffer
       clone.mpBuffer = mpBuffer->getBufferPool()->getBuffer();
       if (!clone.isValid())
          return clone;

       // Copy raw buffer's content to new location
       memcpy(clone.mpBuffer, mpBuffer, mpBuffer->getBufferPool()->getBlockSize());

       // Init clone
       clone->mpInitClone(clone.mpBuffer);

       return clone;
    }


/* ============================ MANIPULATORS ============================== */



    MpBufPtr &operator=(const MpBufPtr &bufferPtr)
    {
        // Check for a=a case;
        if (&bufferPtr == this) {
            return *this;
        }

        if (mpBuffer != NULL)
            mpBuffer->detach();
        mpBuffer = bufferPtr.mpBuffer;
        if (mpBuffer != NULL)
            mpBuffer->attach();

        return *this;
    }


    bool operator==(const MpBufPtr &pBuffer)
    {
        return (mpBuffer == pBuffer.mpBuffer);
    }


    bool operator!=(const MpBufPtr &pBuffer)
    {
        return (mpBuffer != pBuffer.mpBuffer);
    }


    void release()
    {
        if (mpBuffer != NULL)
            mpBuffer->detach();
        mpBuffer = NULL;
    }


    void swap(MpBufPtr &pBuffer)
    {
        MpBuf *temp = pBuffer.mpBuffer;
        pBuffer.mpBuffer = mpBuffer;
        mpBuffer = temp;
    }


    bool requestWrite()
    {
       // We already writable?
       if (isWritable())
          return true;

       // Cannot make buffer writable...
       if (mpBuffer == NULL)
          return false;

       // Create the clone and own it.
       MpBufPtr pBuf = clone();
       swap(pBuf);

       return true;
    }


/* ============================ ACCESSORS ================================= */


    int getBufferNumber() const
    {
        if (mpBuffer == NULL)
            return -1;
        else
            return mpBuffer->mpPool->getBufferNumber(mpBuffer);
    };

    void setFlowGraph(MpFlowGraphBase* flowgraph)
    {
        if(mpBuffer != NULL)
        {
            mpBuffer->setFlowGraph(flowgraph);
        }
    };

    MpBuf *operator->() {assert(mpBuffer!=NULL); return mpBuffer;};

    const MpBuf *operator->() const {assert(mpBuffer!=NULL); return mpBuffer;};

    MP_BUFFERS_TREE getType() const 
    {
        if(mpBuffer) return(mpBuffer->getType());
        else return((MP_BUFFERS_TREE)-1);
    };

/* ============================ INQUIRY =================================== */


    bool isValid() const {return mpBuffer != NULL;};


    bool isWritable() {return (mpBuffer != NULL) && (mpBuffer->mRefCounter == 1);};


/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:
    friend struct MpDataBuf;

    MpBuf *mpBuffer;  

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

};

#define MPBUF_DEFAULT_CONSTRUCTOR(classname)                                \
    classname##Ptr() {};

#define MPBUF_FROM_BASE_CONSTRUCTOR_INIT(classname, buffer_type)            \
            classname *pBuffer = (classname*)mpBuffer;                      \
            assert(pBuffer->mpPool->getBlockSize() >= sizeof(classname));   \
            pBuffer->mType = buffer_type;                                   \
            pBuffer->init();                                                \

#define MPBUF_FROM_BASE_CONSTRUCTOR(classname, buffer_type, base_classname) \
    classname##Ptr(MpBuf *buffer)                                           \
        : base_classname##Ptr(buffer)                                       \
    {                                                                       \
        if (mpBuffer != NULL) {                                             \
            MPBUF_FROM_BASE_CONSTRUCTOR_INIT(classname, buffer_type)        \
        }                                                                   \
    };

#define MPBUF_TYPECHECKED_COPY(classname, buffer_type, base_classname)      \
    classname##Ptr(const MpBufPtr &buffer)                                  \
        : base_classname##Ptr(buffer)                                       \
    {                                                                       \
        assert( (!buffer.isValid())                                         \
              || (  buffer->getType() >= buffer_type                        \
                 && buffer->getType() < buffer_type##_END));                \
    };

#define MPBUF_MEMBER_ACCESS_OPERATOR(classname)                             \
   classname *operator->()                                                  \
      {assert(mpBuffer!=NULL); return (classname*)mpBuffer;};

#define MPBUF_CONST_MEMBER_ACCESS_OPERATOR(classname)                       \
   const classname *operator->() const                                      \
      {assert(mpBuffer!=NULL); return (classname*)mpBuffer;};

#endif // _INCLUDED_MPBUF_H  ]