QStreamer/include/qmediabuffer.h

Go to the documentation of this file.

#pragma once

// QStreamer
//  A GStreamer replacement for Qt.
//
// Authors :
//     Darren R. Starr <submux at gmail dot com>
//
// Copyright :   2010 The QStreamer Project
// License :     BSD (until we're informed that we're in violation of some other license)
// Donations :   Appreciated and possible through SourceForge donation page.
// 
// All code included in this project can be used freely in whatever way the user feels fit.
// If you want to take it, close it and be a weasel that doesn't even contribute back patches,
// so be it. Patches are however appreciated. Wrappers for other open source components are
// also appreciated.
//
// If you wish to be nice to us so we can see how our code is being used. Drop us a mail and let us
// know you're using it in your project.
//
// Support : By default the support is "you get what you pay for". Paid nothing, there's no implied
//           requirement to support you. On the other hand, some project developers are likely to 
//           make fixes, changes, features on request or contract.
//
// Enjoy

#include <QtCore/Qt>
#include <QtCore/QHash>
#include <QtCore/QVariant>

namespace QStreamer
{
        class QMediaBuffer
        {
        public:
                QMediaBuffer(quint64 size, quint32 type='unkn');

                QMediaBuffer(quint8 *buffer, quint64 size, quint32 type='unkn');

                virtual void reference();

                virtual void release();

                bool isValid() const;

                quint32 type() const;

                quint64 size() const;

                quint64 length() const;

                void setLength(quint64 length);

                const quint8 *data() const;

                quint8 *bufferStart();

                const quint8 *bufferStart() const;

                bool clipHead(quint64 count);

                bool clipTail(quint64 count);

                quint64 adjustedSize() const;

                quint64 spaceRemaining() const;

                void resetHead();

                QVariant property(quint32 type) const;

                void setProperty(quint32 type, const QVariant &value);

                void clearProperties();

        protected:
                virtual ~QMediaBuffer();
        
                virtual void bufferReleased();

                virtual void scheduleDelete();

        private:
                quint32 m_referenceCounter;
                quint32 m_type;
                bool m_dataOwner;
                quint8 *m_data;
                quint8 *m_bufferStart;
                quint64 m_size;
                quint64 m_length;

                QHash<quint32, QVariant>m_properties;
        };

        inline QMediaBuffer::QMediaBuffer(quint64 size, quint32 type) :
                m_referenceCounter(0),
                m_type(type),
                m_size(0),
                m_dataOwner(true),
                m_data(0),
                m_bufferStart(0),
                m_length(0)
        {
                m_data = new quint8[size];
                if(m_data)
                {
                        m_size = size;
                        m_bufferStart = m_data;
                }
        }

        inline QMediaBuffer::QMediaBuffer(quint8 *buffer, quint64 size, quint32 type) :
                m_referenceCounter(0),
                m_type(type),
                m_size(size),
                m_dataOwner(false),
                m_data(buffer),
                m_bufferStart(buffer),
                m_length(0)
        {

        }

        inline QMediaBuffer::~QMediaBuffer()
        {
                if(m_dataOwner)
                        delete [] m_data;
        }

        inline bool QMediaBuffer::isValid() const
        {
                return m_data ? true : false;
        }

        inline void QMediaBuffer::reference()
        {
                m_referenceCounter++;
        }

        inline void QMediaBuffer::release()
        {
                if(!m_referenceCounter)
                {
                        // TODO : Throw some sort of error here on buffers being released too many times
                        return;
                }

                m_referenceCounter--;
                if(!m_referenceCounter)
                {
                        scheduleDelete();
                }
        }

        inline quint32 QMediaBuffer::type() const
        {
                return m_type;
        }

        inline quint64 QMediaBuffer::size() const
        {
                return m_size;
        }

        inline quint64 QMediaBuffer::length() const
        {
                return m_length;
        }

        inline void QMediaBuffer::setLength(quint64 length)
        {
                // TODO : check bounds here against adjusted size
                m_length = length;
        }

        inline const quint8 *QMediaBuffer::data() const
        {
                return m_data;
        }

        inline quint8 *QMediaBuffer::bufferStart()
        {
                return m_bufferStart;
        }

        inline const quint8 *QMediaBuffer::bufferStart() const
        {
                return m_bufferStart;
        }

        inline bool QMediaBuffer::clipHead(quint64 count)
        {
                if(m_length < count)
                {
                        // TODO : set an error message of some type here
                        return false;
                }
                m_bufferStart += count;
                m_length -= count;
        }

        inline bool QMediaBuffer::clipTail(quint64 count)
        {
                if(m_length < count)
                {
                        // TODO : set an error message of some type here
                        return false;
                }

                m_length -= count;
        }

        inline quint64 QMediaBuffer::adjustedSize() const
        {
                return m_size - (m_bufferStart - m_data);
        }

        inline quint64 QMediaBuffer::spaceRemaining() const
        {
                return adjustedSize() - m_length;
        }

        inline void QMediaBuffer::resetHead()
        {
                quint64 difference = m_bufferStart - m_data;
                if(difference)
                {
                        m_length += difference;
                        m_bufferStart = m_data;
                }
        }

        inline void QMediaBuffer::bufferReleased()
        {
        }

        inline void QMediaBuffer::scheduleDelete()
        {
                delete this;
        }

        inline QVariant QMediaBuffer::property(quint32 type) const
        {
                return m_properties[type];
        }

        inline void QMediaBuffer::setProperty(quint32 type, const QVariant &value)
        {
                m_properties[type] = value;
        }

        inline void QMediaBuffer::clearProperties()
        {
                m_properties.clear();
        }
}