rtpmemorymanager.h

Go to the documentation of this file.

/*

  This file is a part of JRTPLIB
  Copyright (c) 1999-2006 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com

  This library was developed at the "Expertisecentrum Digitale Media"
  (http://www.edm.uhasselt.be), a research center of the Hasselt University
  (http://www.uhasselt.be). The library is based upon work done for 
  my thesis at the School for Knowledge Technology (Belgium/The Netherlands).

  Permission is hereby granted, free of charge, to any person obtaining a
  copy of this software and associated documentation files (the "Software"),
  to deal in the Software without restriction, including without limitation
  the rights to use, copy, modify, merge, publish, distribute, sublicense,
  and/or sell copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included
  in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  IN THE SOFTWARE.

*/

#ifndef RTPMEMORYMANAGER_H

#define RTPMEMORYMANAGER_H

#include "rtpconfig.h"
#include "rtptypes.h"

#define RTPMEM_TYPE_OTHER                                                       0

#define RTPMEM_TYPE_BUFFER_RECEIVEDRTPPACKET                                    1

#define RTPMEM_TYPE_BUFFER_RECEIVEDRTCPPACKET                                   2

#define RTPMEM_TYPE_BUFFER_RTCPAPPPACKET                                        3

#define RTPMEM_TYPE_BUFFER_RTCPBYEPACKET                                        4

#define RTPMEM_TYPE_BUFFER_RTCPBYEREASON                                        5

#define RTPMEM_TYPE_BUFFER_RTCPCOMPOUNDPACKET                                   6

#define RTPMEM_TYPE_BUFFER_RTCPSDESBLOCK                                        7

#define RTPMEM_TYPE_BUFFER_RTPPACKET                                            8

#define RTPMEM_TYPE_BUFFER_RTPPACKETBUILDERBUFFER                               9

#define RTPMEM_TYPE_BUFFER_SDESITEM                                             10

#define RTPMEM_TYPE_CLASS_ACCEPTIGNOREHASHELEMENT                               11

#define RTPMEM_TYPE_CLASS_ACCEPTIGNOREPORTINFO                                  12

#define RTPMEM_TYPE_CLASS_DESTINATIONLISTHASHELEMENT                            13

#define RTPMEM_TYPE_CLASS_MULTICASTHASHELEMENT                                  14

#define RTPMEM_TYPE_CLASS_RTCPAPPPACKET                                         15

#define RTPMEM_TYPE_CLASS_RTCPBYEPACKET                                         16

#define RTPMEM_TYPE_CLASS_RTCPCOMPOUNDPACKETBUILDER                             17

#define RTPMEM_TYPE_CLASS_RTCPRECEIVERREPORT                                    18

#define RTPMEM_TYPE_CLASS_RTCPRRPACKET                                          19

#define RTPMEM_TYPE_CLASS_RTCPSDESPACKET                                        20

#define RTPMEM_TYPE_CLASS_RTCPSRPACKET                                          21

#define RTPMEM_TYPE_CLASS_RTCPUNKNOWNPACKET                                     22

#define RTPMEM_TYPE_CLASS_RTPADDRESS                                            23

#define RTPMEM_TYPE_CLASS_RTPINTERNALSOURCEDATA                                 24

#define RTPMEM_TYPE_CLASS_RTPPACKET                                             25

#define RTPMEM_TYPE_CLASS_RTPPOLLTHREAD                                         26

#define RTPMEM_TYPE_CLASS_RTPRAWPACKET                                          27

#define RTPMEM_TYPE_CLASS_RTPTRANSMISSIONINFO                                   28

#define RTPMEM_TYPE_CLASS_RTPTRANSMITTER                                        29

#define RTPMEM_TYPE_CLASS_SDESPRIVATEITEM                                       30

#define RTPMEM_TYPE_CLASS_SDESSOURCE                                            31

#define RTPMEM_TYPE_CLASS_SOURCETABLEHASHELEMENT                                32

class RTPMemoryManager
{
public: 
        RTPMemoryManager()                                                                      { }
        virtual ~RTPMemoryManager()                                                             { }
        
        virtual void *AllocateBuffer(size_t numbytes, int memtype) = 0;

        virtual void FreeBuffer(void *buffer) = 0;
};

#ifdef RTP_SUPPORT_MEMORYMANAGEMENT     

#include <new>

inline void *operator new(size_t numbytes, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                return operator new(numbytes);
        return mgr->AllocateBuffer(numbytes,memtype);
}

inline void operator delete(void *buffer, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                operator delete(buffer);
        else
                mgr->FreeBuffer(buffer);
}

#if defined(WIN32) || defined(_WIN32_WCE)
#if _MSC_VER >= 1300
inline void *operator new[](size_t numbytes, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                return operator new[](numbytes);
        return mgr->AllocateBuffer(numbytes,memtype);
}

inline void operator delete[](void *buffer, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                operator delete[](buffer);
        else
                mgr->FreeBuffer(buffer);
}
#endif // _MSC_VER >= 1300
#else
inline void *operator new[](size_t numbytes, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                return operator new[](numbytes);
        return mgr->AllocateBuffer(numbytes,memtype);
}

inline void operator delete[](void *buffer, RTPMemoryManager *mgr, int memtype)
{
        if (mgr == 0)
                operator delete[](buffer);
        else
                mgr->FreeBuffer(buffer);
}
#endif // WIN32 || _WIN32_WCE

inline void RTPDeleteByteArray(uint8_t *buf, RTPMemoryManager *mgr)
{
        if (mgr == 0)
                delete [] buf;
        else
                mgr->FreeBuffer(buf);
}

template<class ClassName> 
inline void RTPDelete(ClassName *obj, RTPMemoryManager *mgr)
{
        if (mgr == 0)
                delete obj;
        else
        {
                obj->~ClassName();
                mgr->FreeBuffer(obj);
        }
}

#define RTPNew(a,b)                     new(a,b)

#else

#define RTPNew(a,b)                     new
#define RTPDelete(a,b)                  delete a
#define RTPDeleteByteArray(a,b)         delete [] a;

#endif // RTP_SUPPORT_MEMORYMANAGEMENT

#endif // RTPMEMORYMANAGER_H