Kwave::MimeData::Buffer Class Reference

Inheritance diagram for Kwave::MimeData::Buffer:

Collaboration diagram for Kwave::MimeData::Buffer:

Public Member Functions
	Buffer ()
virtual	~Buffer () Q_DECL_OVERRIDE
virtual qint64	size () const Q_DECL_OVERRIDE
bool	mapToByteArray ()
const QByteArray &	byteArray () const
virtual void	close () Q_DECL_OVERRIDE

Protected Member Functions
virtual qint64	readData (char *data, qint64 maxlen) Q_DECL_OVERRIDE
virtual qint64	writeData (const char *data, qint64 len) Q_DECL_OVERRIDE

Private Attributes
Kwave::Handle	m_block
qint64	m_size
QByteArray	m_data

Detailed Description

interal class for buffering huge amounts of mime data with support for swap files (using Kwave::MemoryManager). Used as a "write only" stream, after writing the data can be memory mapped and accessed through a QByteArray.

Definition at line 89 of file MimeData.h.

Constructor & Destructor Documentation

Buffer()

Kwave::MimeData::Buffer::Buffer

(

)

Constructor

Definition at line 56 of file MimeData.cpp.

    :QIODevice(), m_block(0), m_size(0), m_data()
{
}

~Buffer()

Kwave::MimeData::Buffer::~Buffer ( )

virtual

Destructor, closes the buffer

Definition at line 62 of file MimeData.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

byteArray()

const QByteArray& Kwave::MimeData::Buffer::byteArray ( ) const

inline

Returns the mapped data as a QByteArray

Definition at line 109 of file MimeData.h.

Referenced by Kwave::MimeData::encode().

{ return m_data; }

Here is the caller graph for this function:

close()

void Kwave::MimeData::Buffer::close ( )

virtual

Closes the buffer and frees the memory (calling multiple times is allowed)

Definition at line 153 of file MimeData.cpp.

References Kwave::MemoryManager::free(), Kwave::MemoryManager::instance(), m_block, m_data, m_size, and Kwave::MemoryManager::unmap().

Referenced by Kwave::MimeData::clear(), Kwave::MimeData::encode(), and ~Buffer().

{
    QIODevice::close();

    // reset the byte array and it's connection to the block of memory
    m_data.setRawData(Q_NULLPTR, 0);
    m_data.clear();

    // unmap and discard the mapped memory
    if (m_block) {
        Kwave::MemoryManager &mem = Kwave::MemoryManager::instance();
        mem.unmap(m_block);
        mem.free(m_block);
        m_block = 0;
    }
    m_size = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mapToByteArray()

bool Kwave::MimeData::Buffer::mapToByteArray

(

)

Try to map the memory to a QByteArray

Definition at line 127 of file MimeData.cpp.

References Kwave::MemoryManager::free(), Kwave::MemoryManager::instance(), m_block, m_data, m_size, Kwave::MemoryManager::map(), and Kwave::toUint().

Referenced by Kwave::MimeData::encode().

{
    // reset our QByteArray
    m_data.setRawData(Q_NULLPTR, 0);
    m_data.clear();

    Kwave::MemoryManager &mem = Kwave::MemoryManager::instance();
    const char *raw = (m_block) ?
        static_cast<const char *>(mem.map(m_block)) : Q_NULLPTR;
    if (!raw) {
        // mapping failed: free the block here to avoid trouble
        // in close()
        mem.free(m_block);
        m_block = 0;
        qWarning("Kwave::MimeData::Buffer::mapToByteArray() failed");
        return false; // mmap failed
    }

    // attach the mapped memory to our QByteArray
    const unsigned int len = Kwave::toUint(m_size);
//    qDebug("Kwave::MimeData::Buffer::mapToByteArray() - %p [%u]", raw, len);
    m_data.setRawData(raw, len);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

readData()

qint64 Kwave::MimeData::Buffer::readData ( char *  data, qint64  maxlen  )

protectedvirtual

read a block of data from the buffer

Parameters

data	buffer that receives the data
maxlen	maximum number of bytes to read

Returns

number of bytes read or -1 if failed

Definition at line 68 of file MimeData.cpp.

References Kwave::MemoryManager::instance(), m_block, Kwave::MemoryManager::readFrom(), size(), and Kwave::toUint().

{
    if (atEnd() || (pos() >= size())) return -1;
    if (pos() + maxlen > size())
        maxlen = size() - pos();

    Kwave::MemoryManager &mem = Kwave::MemoryManager::instance();
    return mem.readFrom(
        m_block,
        Kwave::toUint(pos()),
        data,
        Kwave::toUint(maxlen)
    );
}

Here is the call graph for this function:

size()

virtual qint64 Kwave::MimeData::Buffer::size ( ) const

inlinevirtual

returns the number of bytes written

Definition at line 99 of file MimeData.h.

Referenced by readData().

{ return m_size; }

Here is the caller graph for this function:

writeData()

qint64 Kwave::MimeData::Buffer::writeData ( const char *  data, qint64  len  )

protectedvirtual

write a block of data, internally increments the buffer size if necessary

Parameters

data	pointer to a buffer with data to write
len	number of bytes to write

Returns

number of bytes written or -1 if failed

Definition at line 84 of file MimeData.cpp.

References Kwave::MemoryManager::allocate(), BUFFER_BLOCK_SIZE, Kwave::MemoryManager::instance(), m_block, m_size, Kwave::MemoryManager::resize(), Kwave::MemoryManager::sizeOf(), and Kwave::MemoryManager::writeTo().

{
    Kwave::MemoryManager &mem = Kwave::MemoryManager::instance();
    quint64 new_size = pos() + len;

    // clip the mime data buffer at the "unsigned int" border
    if (new_size > std::numeric_limits<unsigned int>::max())
        return -1;

    // round up the block size if it can no longer be considered to be a
    // small block (~ half of block size), avoid wasting too much memory
    // if the needed size is very small.
    if (new_size > (BUFFER_BLOCK_SIZE / 2))
        new_size = Kwave::round_up<qint64>(new_size, BUFFER_BLOCK_SIZE);

    if (!m_block) {
        // first call: allocate a new memory object
        m_block = mem.allocate(static_cast<size_t>(new_size));
        if (!m_block) return -1; // allocation failed
    }

    if ((pos() + len) > static_cast<qint64>(mem.sizeOf(m_block))) {
        if (!mem.resize(m_block, static_cast<size_t>(new_size)))
            return -1; // resize failed
    }

    // write to the memory block (may be physical or swap file)
    qint64 written = mem.writeTo(
        m_block,
        static_cast<unsigned int>(pos()),
        data,
        static_cast<unsigned int>(len)
    );
    if (written < 0)
        return -1; // write failed: disk full?

    if (pos() + written > m_size)
        m_size = pos() + written ; // push the "m_size"

    return written; // write operation was successful
}

Here is the call graph for this function:

Member Data Documentation

m_block

Kwave::Handle Kwave::MimeData::Buffer::m_block

private

handle of the block of memory (see MemoryManager)

Definition at line 141 of file MimeData.h.

Referenced by close(), mapToByteArray(), readData(), and writeData().

m_data

QByteArray Kwave::MimeData::Buffer::m_data

private

simple array for storage of the wave data

Definition at line 147 of file MimeData.h.

Referenced by close(), and mapToByteArray().

m_size

qint64 Kwave::MimeData::Buffer::m_size

private

number of total bytes written

Definition at line 144 of file MimeData.h.

Referenced by close(), mapToByteArray(), and writeData().

---

The documentation for this class was generated from the following files:

• libkwave/MimeData.h
• libkwave/MimeData.cpp