---

bufferpool.hh

Go to the documentation of this file.

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, rolf@dubitzky.de
 */

/*
 * 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 ! defined ( BUFFERPOOL_HH )
#define BUFFERPOOL_HH

// std c
#include <time.h> 

// std c++
#include <string>
#include <vector>
#include <map>

// PIAVE
#include "piave_base.hh"

namespace PIAVE {

    class Pool;
    /*  simple refcounted buffer  */
    class Buffer
    {
      public:
        Buffer() : 
          _refCount( 0 ), _b( 0 ), _pool( 0 ) {};
        uint8_t    * buf() const { return _b; }
        void         setBuffer( uint8_t * b ) { _b=b; }
        int          getRefCount() const { return _refCount; }
        int          incRef() { return ++_refCount; }
        int          dropRef() { if (_refCount==0) { WARN("!!");return 0;} return --_refCount; }
        void         dropAllRefs() { _refCount = 0; }
        Pool       * getPool() const { return _pool; }
        void         setPool( Pool * p ) { _pool = p; }
      private:
        int        _refCount;
        uint8_t  * _b;
        Pool     * _pool;
        /* hide */
        Buffer( const Buffer & o ) {};
        Buffer & operator = ( const Buffer & o ) {};
    };

// FIXME replace all this stuff by somethning less embarassing
#define FBUFSIZE 1024
    struct Pool 
    {
        Pool( int s ) : size( s ) { 
            for ( int i=0; i<FBUFSIZE; i++ ) {
                pool[i].setPool( this );
            }
        }
//            void clear() {  memset( pool, 0, sizeof(pool) ); }
        Buffer pool[FBUFSIZE];
        int   size;
    };
    typedef std::map< int, Pool* > PoolMap;

    /*
     *  BufferPool this thing works because we usually always
     *  need amny buffers of the same size once we allocte a certain
     *  size, we can probably use a buffer of same size later
     */
    class BufferPool
    {
      public:
        static BufferPool * Inst() { 
            if (!_instance) {
                _instance = new BufferPool();
            }
            return _instance;
        }
        static void printStats();
//        static void clearAll();

        // get a buffer if size size, allocate if not available
        static Buffer * getNewBuffer( size_t size );

      private:
        BufferPool();
        ~BufferPool();

        PoolMap _poolMap;

        static BufferPool * _instance;
    };

};

#endif 

---