mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-16 05:13:58 -07:00
58360a629c
- use helper functions to reduce occurrences of BLOCK_SIZE and SECTOR_SIZE - wmi: provide for shutting it down (gets rid of its two threads); only initialize if actually needed (costs 200ms) - ogl_tex: don't complain if there's no gfx_card info (due to not having used wmi) This was SVN commit r5572.
101 lines
2.4 KiB
C++
101 lines
2.4 KiB
C++
#include "precompiled.h"
|
|
#include "write_buffer.h"
|
|
|
|
#include "lib/bits.h" // IsAligned
|
|
#include "lib/sysdep/cpu.h"
|
|
#include "io.h"
|
|
#include "io_align.h"
|
|
|
|
|
|
WriteBuffer::WriteBuffer()
|
|
: m_capacity(4096), m_data(io_Allocate(m_capacity)), m_size(0)
|
|
{
|
|
}
|
|
|
|
|
|
void WriteBuffer::Append(const void* data, size_t size)
|
|
{
|
|
while(m_size + size > m_capacity)
|
|
m_capacity *= 2;
|
|
shared_ptr<u8> newData = io_Allocate(m_capacity);
|
|
cpu_memcpy(newData.get(), m_data.get(), m_size);
|
|
m_data = newData;
|
|
|
|
cpu_memcpy(m_data.get() + m_size, data, size);
|
|
m_size += size;
|
|
}
|
|
|
|
|
|
void WriteBuffer::Overwrite(const void* data, size_t size, size_t offset)
|
|
{
|
|
debug_assert(offset+size < m_size);
|
|
cpu_memcpy(m_data.get()+offset, data, size);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// UnalignedWriter
|
|
//-----------------------------------------------------------------------------
|
|
|
|
UnalignedWriter::UnalignedWriter(PIFile file, off_t ofs)
|
|
: m_file(file), m_alignedBuf(io_Allocate(BLOCK_SIZE))
|
|
{
|
|
m_alignedOfs = AlignedOffset(ofs);
|
|
const size_t misalignment = (size_t)(ofs - m_alignedOfs);
|
|
if(misalignment)
|
|
io_ReadAligned(m_file, m_alignedOfs, m_alignedBuf.get(), BLOCK_SIZE);
|
|
m_bytesUsed = misalignment;
|
|
}
|
|
|
|
|
|
UnalignedWriter::~UnalignedWriter()
|
|
{
|
|
Flush();
|
|
}
|
|
|
|
|
|
LibError UnalignedWriter::Append(const u8* data, size_t size) const
|
|
{
|
|
while(size != 0)
|
|
{
|
|
// optimization: write directly from the input buffer, if possible
|
|
const size_t alignedSize = (size / BLOCK_SIZE) * BLOCK_SIZE;
|
|
if(m_bytesUsed == 0 && IsAligned(data, SECTOR_SIZE) && alignedSize != 0)
|
|
{
|
|
RETURN_ERR(io_WriteAligned(m_file, m_alignedOfs, data, alignedSize));
|
|
m_alignedOfs += (off_t)alignedSize;
|
|
data += alignedSize;
|
|
size -= alignedSize;
|
|
}
|
|
|
|
const size_t chunkSize = std::min(size, BLOCK_SIZE-m_bytesUsed);
|
|
cpu_memcpy(m_alignedBuf.get()+m_bytesUsed, data, chunkSize);
|
|
m_bytesUsed += chunkSize;
|
|
data += chunkSize;
|
|
size -= chunkSize;
|
|
|
|
if(m_bytesUsed == BLOCK_SIZE)
|
|
RETURN_ERR(WriteBlock());
|
|
}
|
|
|
|
return INFO::OK;
|
|
}
|
|
|
|
|
|
void UnalignedWriter::Flush() const
|
|
{
|
|
if(m_bytesUsed)
|
|
{
|
|
memset(m_alignedBuf.get()+m_bytesUsed, 0, BLOCK_SIZE-m_bytesUsed);
|
|
(void)WriteBlock();
|
|
}
|
|
}
|
|
|
|
|
|
LibError UnalignedWriter::WriteBlock() const
|
|
{
|
|
RETURN_ERR(io_WriteAligned(m_file, m_alignedOfs, m_alignedBuf.get(), BLOCK_SIZE));
|
|
m_alignedOfs += BLOCK_SIZE;
|
|
m_bytesUsed = 0;
|
|
return INFO::OK;
|
|
}
|