683 lines
22 KiB
C
683 lines
22 KiB
C
|
/*
|
||
|
|
* Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>.
|
||
|
|
* All rights reserved. Distributed under the terms of the MIT License.
|
||
|
|
*
|
||
|
|
* Copyright 2002-2004 Maxim Shemanarev (http://www.antigrain.com)
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* Class scanline_storage_subpix, a slightly modified version of
|
||
|
|
* scanline_storage customized to store 3 covers per pixel
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef AGG_SCANLINE_STORAGE_SUBPIX_INCLUDED
|
||
|
|
#define AGG_SCANLINE_STORAGE_SUBPIX_INCLUDED
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <math.h>
|
||
|
|
#include "agg_array.h"
|
||
|
|
#include "agg_scanline_storage_aa.h"
|
||
|
|
|
||
|
|
|
||
|
|
namespace agg
|
||
|
|
{
|
||
|
|
//--------------------------------------------scanline_storage_subpix
|
||
|
|
template<class T> class scanline_storage_subpix
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef T cover_type;
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
struct span_data
|
||
|
|
{
|
||
|
|
int32 x;
|
||
|
|
int32 len; // If negative, it's a solid span, covers is valid
|
||
|
|
int covers_id; // The index of the cells in the scanline_cell_storage
|
||
|
|
};
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
struct scanline_data
|
||
|
|
{
|
||
|
|
int y;
|
||
|
|
unsigned num_spans;
|
||
|
|
unsigned start_span;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
class embedded_scanline
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-----------------------------------------------------------
|
||
|
|
class const_iterator
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
struct span
|
||
|
|
{
|
||
|
|
int32 x;
|
||
|
|
int32 len; // If negative, it's a solid span, covers is valid
|
||
|
|
const T* covers;
|
||
|
|
};
|
||
|
|
|
||
|
|
const_iterator() : m_storage(0) {}
|
||
|
|
const_iterator(const embedded_scanline& sl) :
|
||
|
|
m_storage(sl.m_storage),
|
||
|
|
m_span_idx(sl.m_scanline.start_span)
|
||
|
|
{
|
||
|
|
init_span();
|
||
|
|
}
|
||
|
|
|
||
|
|
const span& operator*() const { return m_span; }
|
||
|
|
const span* operator->() const { return &m_span; }
|
||
|
|
|
||
|
|
void operator ++ ()
|
||
|
|
{
|
||
|
|
++m_span_idx;
|
||
|
|
init_span();
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
void init_span()
|
||
|
|
{
|
||
|
|
const span_data& s = m_storage->span_by_index(m_span_idx);
|
||
|
|
m_span.x = s.x;
|
||
|
|
m_span.len = s.len;
|
||
|
|
m_span.covers = m_storage->covers_by_index(s.covers_id);
|
||
|
|
}
|
||
|
|
|
||
|
|
const scanline_storage_subpix* m_storage;
|
||
|
|
unsigned m_span_idx;
|
||
|
|
span m_span;
|
||
|
|
};
|
||
|
|
|
||
|
|
friend class const_iterator;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------
|
||
|
|
embedded_scanline(const scanline_storage_subpix& storage) :
|
||
|
|
m_storage(&storage)
|
||
|
|
{
|
||
|
|
init(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------
|
||
|
|
void reset(int, int) {}
|
||
|
|
unsigned num_spans() const { return m_scanline.num_spans; }
|
||
|
|
int y() const { return m_scanline.y; }
|
||
|
|
const_iterator begin() const { return const_iterator(*this); }
|
||
|
|
|
||
|
|
//-----------------------------------------------------------
|
||
|
|
void init(unsigned scanline_idx)
|
||
|
|
{
|
||
|
|
m_scanline_idx = scanline_idx;
|
||
|
|
m_scanline = m_storage->scanline_by_index(m_scanline_idx);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
const scanline_storage_subpix* m_storage;
|
||
|
|
scanline_data m_scanline;
|
||
|
|
unsigned m_scanline_idx;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
scanline_storage_subpix() :
|
||
|
|
m_covers(),
|
||
|
|
m_spans(256-2), // Block increment size
|
||
|
|
m_scanlines(),
|
||
|
|
m_min_x( 0x7FFFFFFF),
|
||
|
|
m_min_y( 0x7FFFFFFF),
|
||
|
|
m_max_x(-0x7FFFFFFF),
|
||
|
|
m_max_y(-0x7FFFFFFF),
|
||
|
|
m_cur_scanline(0)
|
||
|
|
{
|
||
|
|
m_fake_scanline.y = 0;
|
||
|
|
m_fake_scanline.num_spans = 0;
|
||
|
|
m_fake_scanline.start_span = 0;
|
||
|
|
m_fake_span.x = 0;
|
||
|
|
m_fake_span.len = 0;
|
||
|
|
m_fake_span.covers_id = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Renderer Interface
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
void prepare()
|
||
|
|
{
|
||
|
|
m_covers.remove_all();
|
||
|
|
m_scanlines.remove_all();
|
||
|
|
m_spans.remove_all();
|
||
|
|
m_min_x = 0x7FFFFFFF;
|
||
|
|
m_min_y = 0x7FFFFFFF;
|
||
|
|
m_max_x = -0x7FFFFFFF;
|
||
|
|
m_max_y = -0x7FFFFFFF;
|
||
|
|
m_cur_scanline = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
template<class Scanline> void render(const Scanline& sl)
|
||
|
|
{
|
||
|
|
scanline_data sl_this;
|
||
|
|
|
||
|
|
int y = sl.y();
|
||
|
|
if(y < m_min_y) m_min_y = y;
|
||
|
|
if(y > m_max_y) m_max_y = y;
|
||
|
|
|
||
|
|
sl_this.y = y;
|
||
|
|
sl_this.num_spans = sl.num_spans();
|
||
|
|
sl_this.start_span = m_spans.size();
|
||
|
|
typename Scanline::const_iterator span_iterator = sl.begin();
|
||
|
|
|
||
|
|
unsigned num_spans = sl_this.num_spans;
|
||
|
|
for(;;)
|
||
|
|
{
|
||
|
|
span_data sp;
|
||
|
|
|
||
|
|
sp.x = span_iterator->x;
|
||
|
|
sp.len = span_iterator->len;
|
||
|
|
int len = abs(int(sp.len));
|
||
|
|
sp.covers_id =
|
||
|
|
m_covers.add_cells(span_iterator->covers,
|
||
|
|
(unsigned(len)));
|
||
|
|
m_spans.add(sp);
|
||
|
|
int x1 = sp.x;
|
||
|
|
int x2 = sp.x + len/3 - 1;
|
||
|
|
if(x1 < m_min_x) m_min_x = x1;
|
||
|
|
if(x2 > m_max_x) m_max_x = x2;
|
||
|
|
if(--num_spans == 0) break;
|
||
|
|
++span_iterator;
|
||
|
|
}
|
||
|
|
m_scanlines.add(sl_this);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
// Iterate scanlines interface
|
||
|
|
int min_x() const { return m_min_x; }
|
||
|
|
int min_y() const { return m_min_y; }
|
||
|
|
int max_x() const { return m_max_x; }
|
||
|
|
int max_y() const { return m_max_y; }
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
bool rewind_scanlines()
|
||
|
|
{
|
||
|
|
m_cur_scanline = 0;
|
||
|
|
return m_scanlines.size() > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
template<class Scanline> bool sweep_scanline(Scanline& sl)
|
||
|
|
{
|
||
|
|
sl.reset_spans();
|
||
|
|
for(;;)
|
||
|
|
{
|
||
|
|
if(m_cur_scanline >= m_scanlines.size()) return false;
|
||
|
|
const scanline_data& sl_this = m_scanlines[m_cur_scanline];
|
||
|
|
|
||
|
|
unsigned num_spans = sl_this.num_spans;
|
||
|
|
unsigned span_idx = sl_this.start_span;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
const span_data& sp = m_spans[span_idx++];
|
||
|
|
const T* covers = covers_by_index(sp.covers_id);
|
||
|
|
if(sp.len < 0)
|
||
|
|
{
|
||
|
|
sl.add_span(sp.x, unsigned(-sp.len), *covers);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sl.add_cells(sp.x, sp.len, covers);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(--num_spans);
|
||
|
|
++m_cur_scanline;
|
||
|
|
if(sl.num_spans())
|
||
|
|
{
|
||
|
|
sl.finalize(sl_this.y);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
// Specialization for embedded_scanline
|
||
|
|
bool sweep_scanline(embedded_scanline& sl)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if(m_cur_scanline >= m_scanlines.size()) return false;
|
||
|
|
sl.init(m_cur_scanline);
|
||
|
|
++m_cur_scanline;
|
||
|
|
}
|
||
|
|
while(sl.num_spans() == 0);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
unsigned byte_size() const
|
||
|
|
{
|
||
|
|
unsigned i;
|
||
|
|
unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y
|
||
|
|
|
||
|
|
for(i = 0; i < m_scanlines.size(); ++i)
|
||
|
|
{
|
||
|
|
size += sizeof(int32) * 3; // scanline size in bytes
|
||
|
|
|
||
|
|
const scanline_data& sl_this = m_scanlines[i];
|
||
|
|
|
||
|
|
unsigned num_spans = sl_this.num_spans;
|
||
|
|
unsigned span_idx = sl_this.start_span;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
const span_data& sp = m_spans[span_idx++];
|
||
|
|
|
||
|
|
size += sizeof(int32) * 2; // X, span_len
|
||
|
|
if(sp.len < 0)
|
||
|
|
{
|
||
|
|
size += sizeof(T); // cover
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
size += sizeof(T) * unsigned(sp.len); // covers
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(--num_spans);
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
static void write_int32(int8u* dst, int32 val)
|
||
|
|
{
|
||
|
|
dst[0] = ((const int8u*)&val)[0];
|
||
|
|
dst[1] = ((const int8u*)&val)[1];
|
||
|
|
dst[2] = ((const int8u*)&val)[2];
|
||
|
|
dst[3] = ((const int8u*)&val)[3];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
void serialize(int8u* data) const
|
||
|
|
{
|
||
|
|
unsigned i;
|
||
|
|
|
||
|
|
write_int32(data, min_x()); // min_x
|
||
|
|
data += sizeof(int32);
|
||
|
|
write_int32(data, min_y()); // min_y
|
||
|
|
data += sizeof(int32);
|
||
|
|
write_int32(data, max_x()); // max_x
|
||
|
|
data += sizeof(int32);
|
||
|
|
write_int32(data, max_y()); // max_y
|
||
|
|
data += sizeof(int32);
|
||
|
|
|
||
|
|
for(i = 0; i < m_scanlines.size(); ++i)
|
||
|
|
{
|
||
|
|
const scanline_data& sl_this = m_scanlines[i];
|
||
|
|
|
||
|
|
int8u* size_ptr = data;
|
||
|
|
data += sizeof(int32); // Reserve space for scanline size in bytes
|
||
|
|
|
||
|
|
write_int32(data, sl_this.y); // Y
|
||
|
|
data += sizeof(int32);
|
||
|
|
|
||
|
|
write_int32(data, sl_this.num_spans); // num_spans
|
||
|
|
data += sizeof(int32);
|
||
|
|
|
||
|
|
unsigned num_spans = sl_this.num_spans;
|
||
|
|
unsigned span_idx = sl_this.start_span;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
const span_data& sp = m_spans[span_idx++];
|
||
|
|
const T* covers = covers_by_index(sp.covers_id);
|
||
|
|
|
||
|
|
write_int32(data, sp.x); // X
|
||
|
|
data += sizeof(int32);
|
||
|
|
|
||
|
|
write_int32(data, sp.len); // span_len
|
||
|
|
data += sizeof(int32);
|
||
|
|
|
||
|
|
if(sp.len < 0)
|
||
|
|
{
|
||
|
|
memcpy(data, covers, sizeof(T));
|
||
|
|
data += sizeof(T);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
memcpy(data, covers, unsigned(sp.len) * sizeof(T));
|
||
|
|
data += sizeof(T) * unsigned(sp.len);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(--num_spans);
|
||
|
|
write_int32(size_ptr, int32(unsigned(data - size_ptr)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
const scanline_data& scanline_by_index(unsigned i) const
|
||
|
|
{
|
||
|
|
return (i < m_scanlines.size()) ? m_scanlines[i] : m_fake_scanline;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
const span_data& span_by_index(unsigned i) const
|
||
|
|
{
|
||
|
|
return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
const T* covers_by_index(int i) const
|
||
|
|
{
|
||
|
|
return m_covers[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
scanline_cell_storage<T> m_covers;
|
||
|
|
pod_bvector<span_data, 10> m_spans;
|
||
|
|
pod_bvector<scanline_data, 8> m_scanlines;
|
||
|
|
span_data m_fake_span;
|
||
|
|
scanline_data m_fake_scanline;
|
||
|
|
int m_min_x;
|
||
|
|
int m_min_y;
|
||
|
|
int m_max_x;
|
||
|
|
int m_max_y;
|
||
|
|
unsigned m_cur_scanline;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
typedef scanline_storage_subpix<int8u> scanline_storage_subpix8; //--------scanline_storage_subpix8
|
||
|
|
typedef scanline_storage_subpix<int16u> scanline_storage_subpix16; //--------scanline_storage_subpix16
|
||
|
|
typedef scanline_storage_subpix<int32u> scanline_storage_subpix32; //--------scanline_storage_subpix32
|
||
|
|
|
||
|
|
|
||
|
|
//--------------------------------------serialized_scanlines_adaptor_subpix
|
||
|
|
template<class T> class serialized_scanlines_adaptor_subpix
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef T cover_type;
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------
|
||
|
|
class embedded_scanline
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef T cover_type;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------
|
||
|
|
class const_iterator
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
struct span
|
||
|
|
{
|
||
|
|
int32 x;
|
||
|
|
int32 len; // If negative, it's a solid span, "covers" is valid
|
||
|
|
const T* covers;
|
||
|
|
};
|
||
|
|
|
||
|
|
const_iterator() : m_ptr(0) {}
|
||
|
|
const_iterator(const embedded_scanline& sl) :
|
||
|
|
m_ptr(sl.m_ptr),
|
||
|
|
m_dx(sl.m_dx)
|
||
|
|
{
|
||
|
|
init_span();
|
||
|
|
}
|
||
|
|
|
||
|
|
const span& operator*() const { return m_span; }
|
||
|
|
const span* operator->() const { return &m_span; }
|
||
|
|
|
||
|
|
void operator ++ ()
|
||
|
|
{
|
||
|
|
if(m_span.len < 0)
|
||
|
|
{
|
||
|
|
m_ptr += sizeof(T);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_ptr += m_span.len * sizeof(T);
|
||
|
|
}
|
||
|
|
init_span();
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
int read_int32()
|
||
|
|
{
|
||
|
|
int32 val;
|
||
|
|
((int8u*)&val)[0] = *m_ptr++;
|
||
|
|
((int8u*)&val)[1] = *m_ptr++;
|
||
|
|
((int8u*)&val)[2] = *m_ptr++;
|
||
|
|
((int8u*)&val)[3] = *m_ptr++;
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
void init_span()
|
||
|
|
{
|
||
|
|
m_span.x = read_int32() + m_dx;
|
||
|
|
m_span.len = read_int32();
|
||
|
|
m_span.covers = m_ptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int8u* m_ptr;
|
||
|
|
span m_span;
|
||
|
|
int m_dx;
|
||
|
|
};
|
||
|
|
|
||
|
|
friend class const_iterator;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------
|
||
|
|
embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------
|
||
|
|
void reset(int, int) {}
|
||
|
|
unsigned num_spans() const { return m_num_spans; }
|
||
|
|
int y() const { return m_y; }
|
||
|
|
const_iterator begin() const { return const_iterator(*this); }
|
||
|
|
|
||
|
|
|
||
|
|
private:
|
||
|
|
//-----------------------------------------------------------------
|
||
|
|
int read_int32()
|
||
|
|
{
|
||
|
|
int32 val;
|
||
|
|
((int8u*)&val)[0] = *m_ptr++;
|
||
|
|
((int8u*)&val)[1] = *m_ptr++;
|
||
|
|
((int8u*)&val)[2] = *m_ptr++;
|
||
|
|
((int8u*)&val)[3] = *m_ptr++;
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
public:
|
||
|
|
//-----------------------------------------------------------------
|
||
|
|
void init(const int8u* ptr, int dx, int dy)
|
||
|
|
{
|
||
|
|
m_ptr = ptr;
|
||
|
|
m_y = read_int32() + dy;
|
||
|
|
m_num_spans = unsigned(read_int32());
|
||
|
|
m_dx = dx;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
const int8u* m_ptr;
|
||
|
|
int m_y;
|
||
|
|
unsigned m_num_spans;
|
||
|
|
int m_dx;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
public:
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
serialized_scanlines_adaptor_subpix() :
|
||
|
|
m_data(0),
|
||
|
|
m_end(0),
|
||
|
|
m_ptr(0),
|
||
|
|
m_dx(0),
|
||
|
|
m_dy(0),
|
||
|
|
m_min_x(0x7FFFFFFF),
|
||
|
|
m_min_y(0x7FFFFFFF),
|
||
|
|
m_max_x(-0x7FFFFFFF),
|
||
|
|
m_max_y(-0x7FFFFFFF)
|
||
|
|
{}
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
serialized_scanlines_adaptor_subpix(const int8u* data, unsigned size,
|
||
|
|
double dx, double dy) :
|
||
|
|
m_data(data),
|
||
|
|
m_end(data + size),
|
||
|
|
m_ptr(data),
|
||
|
|
m_dx(iround(dx)),
|
||
|
|
m_dy(iround(dy)),
|
||
|
|
m_min_x(0x7FFFFFFF),
|
||
|
|
m_min_y(0x7FFFFFFF),
|
||
|
|
m_max_x(-0x7FFFFFFF),
|
||
|
|
m_max_y(-0x7FFFFFFF)
|
||
|
|
{}
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
void init(const int8u* data, unsigned size, double dx, double dy)
|
||
|
|
{
|
||
|
|
m_data = data;
|
||
|
|
m_end = data + size;
|
||
|
|
m_ptr = data;
|
||
|
|
m_dx = iround(dx);
|
||
|
|
m_dy = iround(dy);
|
||
|
|
m_min_x = 0x7FFFFFFF;
|
||
|
|
m_min_y = 0x7FFFFFFF;
|
||
|
|
m_max_x = -0x7FFFFFFF;
|
||
|
|
m_max_y = -0x7FFFFFFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
int read_int32()
|
||
|
|
{
|
||
|
|
int32 val;
|
||
|
|
((int8u*)&val)[0] = *m_ptr++;
|
||
|
|
((int8u*)&val)[1] = *m_ptr++;
|
||
|
|
((int8u*)&val)[2] = *m_ptr++;
|
||
|
|
((int8u*)&val)[3] = *m_ptr++;
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
unsigned read_int32u()
|
||
|
|
{
|
||
|
|
int32u val;
|
||
|
|
((int8u*)&val)[0] = *m_ptr++;
|
||
|
|
((int8u*)&val)[1] = *m_ptr++;
|
||
|
|
((int8u*)&val)[2] = *m_ptr++;
|
||
|
|
((int8u*)&val)[3] = *m_ptr++;
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
public:
|
||
|
|
// Iterate scanlines interface
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
bool rewind_scanlines()
|
||
|
|
{
|
||
|
|
m_ptr = m_data;
|
||
|
|
if(m_ptr < m_end)
|
||
|
|
{
|
||
|
|
m_min_x = read_int32() + m_dx;
|
||
|
|
m_min_y = read_int32() + m_dy;
|
||
|
|
m_max_x = read_int32() + m_dx;
|
||
|
|
m_max_y = read_int32() + m_dy;
|
||
|
|
}
|
||
|
|
return m_ptr < m_end;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
int min_x() const { return m_min_x; }
|
||
|
|
int min_y() const { return m_min_y; }
|
||
|
|
int max_x() const { return m_max_x; }
|
||
|
|
int max_y() const { return m_max_y; }
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
template<class Scanline> bool sweep_scanline(Scanline& sl)
|
||
|
|
{
|
||
|
|
sl.reset_spans();
|
||
|
|
for(;;)
|
||
|
|
{
|
||
|
|
if(m_ptr >= m_end) return false;
|
||
|
|
|
||
|
|
read_int32(); // Skip scanline size in bytes
|
||
|
|
int y = read_int32() + m_dy;
|
||
|
|
unsigned num_spans = read_int32();
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
int x = read_int32() + m_dx;
|
||
|
|
int len = read_int32();
|
||
|
|
|
||
|
|
if(len < 0)
|
||
|
|
{
|
||
|
|
sl.add_span(x, unsigned(-len), *m_ptr);
|
||
|
|
m_ptr += sizeof(T);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sl.add_cells(x, len, m_ptr);
|
||
|
|
m_ptr += len * sizeof(T);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(--num_spans);
|
||
|
|
|
||
|
|
if(sl.num_spans())
|
||
|
|
{
|
||
|
|
sl.finalize(y);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//--------------------------------------------------------------------
|
||
|
|
// Specialization for embedded_scanline
|
||
|
|
bool sweep_scanline(embedded_scanline& sl)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if(m_ptr >= m_end) return false;
|
||
|
|
|
||
|
|
unsigned byte_size = read_int32u();
|
||
|
|
sl.init(m_ptr, m_dx, m_dy);
|
||
|
|
m_ptr += byte_size - sizeof(int32);
|
||
|
|
}
|
||
|
|
while(sl.num_spans() == 0);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
const int8u* m_data;
|
||
|
|
const int8u* m_end;
|
||
|
|
const int8u* m_ptr;
|
||
|
|
int m_dx;
|
||
|
|
int m_dy;
|
||
|
|
int m_min_x;
|
||
|
|
int m_min_y;
|
||
|
|
int m_max_x;
|
||
|
|
int m_max_y;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
typedef serialized_scanlines_adaptor_subpix<int8u>
|
||
|
|
serialized_scanlines_adaptor_subpix8; //serialized_scanlines_adaptor_subpix8
|
||
|
|
|
||
|
|
typedef serialized_scanlines_adaptor_subpix<int16u>
|
||
|
|
serialized_scanlines_adaptor_subpix16; //serialized_scanlines_adaptor_subpix16
|
||
|
|
|
||
|
|
typedef serialized_scanlines_adaptor_subpix<int32u>
|
||
|
|
serialized_scanlines_adaptor_subpix32; //serialized_scanlines_adaptor_subpix32
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|