FOR_BLOCKS(length, dst, src, CAST128_BLOCK_SIZE)
{
uint32_t t, l, r;
/* Get inblock into l,r */
l = READ_UINT32(src);
r = READ_UINT32(src+4);
/* Do the work */
F1(l, r, 0);
F2(r, l, 1);
F3(l, r, 2);
F1(r, l, 3);
F2(l, r, 4);
F3(r, l, 5);
F1(l, r, 6);
F2(r, l, 7);
F3(l, r, 8);
F1(r, l, 9);
F2(l, r, 10);
F3(r, l, 11);
/* Only do full 16 rounds if key length > 80 bits */
if (ctx->rounds > 12) {
F1(l, r, 12);
F2(r, l, 13);
F3(l, r, 14);
F1(r, l, 15);
}
/* Put l,r into outblock */
WRITE_UINT32(dst, r);
WRITE_UINT32(dst + 4, l);
/* Wipe clean */
t = l = r = 0;
}
bool unshield_read_common_header(uint8_t** buffer, CommonHeader* common)
{
uint8_t* p = *buffer;
common->signature = READ_UINT32(p); p += 4;
if (CAB_SIGNATURE != common->signature)
{
unshield_error("Invalid file signature");
if (MSCF_SIGNATURE == common->signature)
unshield_warning("Found Microsoft Cabinet header. Use cabextract (http://www.kyz.uklinux.net/cabextract.php) to unpack this file.");
return false;
}
common->version = READ_UINT32(p); p += 4;
common->volume_info = READ_UINT32(p); p += 4;
common->cab_descriptor_offset = READ_UINT32(p); p += 4;
common->cab_descriptor_size = READ_UINT32(p); p += 4;
#if VERBOSE
unshield_trace("Common header: %08x %08x %08x %08x",
common->version,
common->volume_info,
common->cab_descriptor_offset,
common->cab_descriptor_size);
#endif
*buffer = p;
return true;
}
void Lingo::c_ifcode() {
Datum d;
int savepc = g_lingo->_pc; /* then part */
uint then = READ_UINT32(&(*g_lingo->_currentScript)[savepc]);
uint elsep = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 1]);
uint end = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 2]);
uint skipEnd = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 3]);
debugC(8, kDebugLingoExec, "executing cond (have to %s end)", skipEnd ? "skip" : "execute");
g_lingo->execute(savepc + 4); /* condition */
d = g_lingo->pop();
if (d.toInt()) {
debugC(8, kDebugLingoExec, "executing then");
g_lingo->execute(then + savepc - 1);
} else if (elsep) { /* else part? */
debugC(8, kDebugLingoExec, "executing else");
g_lingo->execute(elsep + savepc - 1);
}
if (!g_lingo->_returning && !skipEnd) {
g_lingo->_pc = end + savepc - 1; /* next stmt */
debugC(8, kDebugLingoExec, "executing end");
} else {
debugC(8, kDebugLingoExec, "Skipped end");
}
}
void Lingo::c_repeatwhilecode(void) {
Datum d;
int savepc = g_lingo->_pc;
uint body = READ_UINT32(&(*g_lingo->_currentScript)[savepc]);
uint end = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 1]);
g_lingo->execute(savepc + 2); /* condition */
d = g_lingo->pop();
d.toInt();
while (d.u.i) {
g_lingo->execute(body + savepc - 1); /* body */
if (g_lingo->_returning)
break;
if (g_lingo->_exitRepeat) {
g_lingo->_exitRepeat = false;
break;
}
g_lingo->execute(savepc + 2); /* condition */
d = g_lingo->pop();
d.toInt();
}
if (!g_lingo->_returning)
g_lingo->_pc = end + savepc - 1; /* next stmt */
}
void Lingo::c_theentityassign() {
inst e = (*g_lingo->_currentScript)[g_lingo->_pc++];
inst f = (*g_lingo->_currentScript)[g_lingo->_pc++];
Datum id = g_lingo->pop();
int entity = READ_UINT32(&e);
int field = READ_UINT32(&f);
Datum d = g_lingo->pop();
g_lingo->setTheEntity(entity, id, field, d);
}
void Lingo::c_whencode() {
Datum d;
uint start = g_lingo->_pc;
uint end = READ_UINT32(&(*g_lingo->_currentScript)[start]) + start - 1;
Common::String eventname((char *)&(*g_lingo->_currentScript)[start + 1]);
start += g_lingo->calcStringAlignment(eventname.c_str()) + 1;
debugC(1, kDebugLingoExec, "c_whencode([%5d][%5d], %s)", start, end, eventname.c_str());
int entity = g_lingo->_currentEntityId;
g_lingo->_currentEntityId = 0;
g_lingo->define(eventname, start, 0, NULL, end);
g_lingo->_currentEntityId = entity;
if (debugChannelSet(1, kDebugLingoExec)) {
uint pc = start;
while (pc <= end) {
Common::String instr = g_lingo->decodeInstruction(pc, &pc);
debugC(1, kDebugLingoExec, "[%5d] %s", pc, instr.c_str());
}
}
g_lingo->_pc = end;
}
void Surface::copyToCurrentPortMasked(const Common::Rect &srcRect, const Common::Rect &dstRect, const Surface *mask) const {
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getCurSurface();
byte *src = (byte *)_surface->getBasePtr(srcRect.left, srcRect.top);
byte *dst = (byte *)screen->getBasePtr(dstRect.left, dstRect.top);
int lineSize = srcRect.width() * _surface->format.bytesPerPixel;
for (int y = 0; y < srcRect.height(); y++) {
byte *maskSrc = (byte *)mask->getSurface()->getBasePtr(0, y);
for (int x = 0; x < srcRect.width(); x++) {
if (g_system->getScreenFormat().bytesPerPixel == 2) {
uint16 color = READ_UINT16(maskSrc);
if (!isTransparent(color))
memcpy(dst, src, 2);
} else if (g_system->getScreenFormat().bytesPerPixel == 4) {
uint32 color = READ_UINT32(maskSrc);
if (!isTransparent(color))
memcpy(dst, src, 4);
}
src += g_system->getScreenFormat().bytesPerPixel;
maskSrc += g_system->getScreenFormat().bytesPerPixel;
dst += g_system->getScreenFormat().bytesPerPixel;
}
src += _surface->pitch - lineSize;
dst += screen->pitch - lineSize;
}
}
void Lingo::c_constpush() {
Datum d;
inst i = (*g_lingo->_currentScript)[g_lingo->_pc++];
d.u.i = READ_UINT32(&i);
d.type = INT;
g_lingo->push(d);
}
void Surface::copyToCurrentPortTransparentGlow(const Common::Rect &srcRect, const Common::Rect &dstRect) const {
// This is the same as copyToCurrentPortTransparent(), but turns the red value of each
// pixel all the way up.
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getCurSurface();
byte *src = (byte *)_surface->getBasePtr(srcRect.left, srcRect.top);
byte *dst = (byte *)screen->getBasePtr(dstRect.left, dstRect.top);
int lineSize = srcRect.width() * _surface->format.bytesPerPixel;
for (int y = 0; y < srcRect.height(); y++) {
for (int x = 0; x < srcRect.width(); x++) {
if (g_system->getScreenFormat().bytesPerPixel == 2) {
uint16 color = READ_UINT16(src);
if (!isTransparent(color))
WRITE_UINT16(dst, getGlowColor(color));
} else if (g_system->getScreenFormat().bytesPerPixel == 4) {
uint32 color = READ_UINT32(src);
if (!isTransparent(color))
WRITE_UINT32(dst, getGlowColor(color));
}
src += g_system->getScreenFormat().bytesPerPixel;
dst += g_system->getScreenFormat().bytesPerPixel;
}
src += _surface->pitch - lineSize;
dst += screen->pitch - lineSize;
}
}
void Surface::scaleTransparentCopy(const Common::Rect &srcRect, const Common::Rect &dstRect) const {
// I'm doing simple linear scaling here
// dstRect(x, y) = srcRect(x * srcW / dstW, y * srcH / dstH);
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getCurSurface();
int srcW = srcRect.width();
int srcH = srcRect.height();
int dstW = dstRect.width();
int dstH = dstRect.height();
for (int y = 0; y < dstH; y++) {
for (int x = 0; x < dstW; x++) {
if (g_system->getScreenFormat().bytesPerPixel == 2) {
uint16 color = READ_UINT16((byte *)_surface->getBasePtr(
x * srcW / dstW + srcRect.left,
y * srcH / dstH + srcRect.top));
if (!isTransparent(color))
WRITE_UINT16((byte *)screen->getBasePtr(x + dstRect.left, y + dstRect.top), color);
} else if (g_system->getScreenFormat().bytesPerPixel == 4) {
uint32 color = READ_UINT32((byte *)_surface->getBasePtr(
x * srcW / dstW + srcRect.left,
y * srcH / dstH + srcRect.top));
if (!isTransparent(color))
WRITE_UINT32((byte *)screen->getBasePtr(x + dstRect.left, y + dstRect.top), color);
}
}
}
}
void Surface::scaleTransparentCopyGlow(const Common::Rect &srcRect, const Common::Rect &dstRect) const {
// This is the same as scaleTransparentCopy(), but turns the red value of each
// pixel all the way up.
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getCurSurface();
int srcW = srcRect.width();
int srcH = srcRect.height();
int dstW = dstRect.width();
int dstH = dstRect.height();
for (int y = 0; y < dstH; y++) {
for (int x = 0; x < dstW; x++) {
if (g_system->getScreenFormat().bytesPerPixel == 2) {
uint16 color = READ_UINT16((byte *)_surface->getBasePtr(
x * srcW / dstW + srcRect.left,
y * srcH / dstH + srcRect.top));
if (!isTransparent(color))
WRITE_UINT16((byte *)screen->getBasePtr(x + dstRect.left, y + dstRect.top), getGlowColor(color));
} else if (g_system->getScreenFormat().bytesPerPixel == 4) {
uint32 color = READ_UINT32((byte *)_surface->getBasePtr(
x * srcW / dstW + srcRect.left,
y * srcH / dstH + srcRect.top));
if (!isTransparent(color))
WRITE_UINT32((byte *)screen->getBasePtr(x + dstRect.left, y + dstRect.top), getGlowColor(color));
}
}
}
}
void CloudIcon::makeAlphaIcon(const Graphics::Surface &icon, float alpha) {
_alphaIcon.copyFrom(icon);
byte *pixels = (byte *)_alphaIcon.getPixels();
for (int y = 0; y < _alphaIcon.h; y++) {
byte *row = pixels + y * _alphaIcon.pitch;
for (int x = 0; x < _alphaIcon.w; x++) {
uint32 srcColor;
if (_alphaIcon.format.bytesPerPixel == 2)
srcColor = READ_UINT16(row);
else if (_alphaIcon.format.bytesPerPixel == 3)
srcColor = READ_UINT24(row);
else
srcColor = READ_UINT32(row);
// Update color's alpha
byte r, g, b, a;
_alphaIcon.format.colorToARGB(srcColor, a, r, g, b);
a = (byte)(a * alpha);
uint32 color = _alphaIcon.format.ARGBToColor(a, r, g, b);
if (_alphaIcon.format.bytesPerPixel == 2)
*((uint16 *)row) = color;
else
*((uint32 *)row) = color;
row += _alphaIcon.format.bytesPerPixel;
}
}
}
/* in the ENDISx register, FALSE to disable the interrupt */
static os_status setInterruptEnable(os_hwi_handle hwi_num,
bool enable_interrupt)
{
uint16_t index;
uint32_t endis_reg = 0;
uint32_t *endis_reg_ptr;
os_hwi_handle epic_hwi_num = 0;
uint32_t interrupt_bit = 0;
/* Don't handle Non-EPIC interrupts don't require any more handling */
if (hwi_num < EPIC_INTERRUPTS_OFFSET)
RETURN_ERROR(OS_ERR_HWI_INVALID);
else /* get the EPIC interrupt zero-based index */
epic_hwi_num = (os_hwi_handle)(hwi_num - EPIC_INTERRUPTS_OFFSET);
/* handle the Enable/Disable Interrupts register ENDISx */
index = (os_hwi_handle)(epic_hwi_num >> 5); /* /32 , there are 8 ENDISx registers*/
endis_reg_ptr = (uint32_t *)((g_dsp_plat_map->epic).p_endis);
endis_reg_ptr += index;
/* we need to set or clear the corresponding interrupt bit */
interrupt_bit = (uint32_t)(0x00000001 << (epic_hwi_num & 0x001F));
READ_UINT32(endis_reg, *endis_reg_ptr);
if (enable_interrupt)
endis_reg |= interrupt_bit;
else
endis_reg &= ~interrupt_bit;
WRITE_UINT32(*endis_reg_ptr, endis_reg);
return OS_SUCCESS;
}
/* Caution: call only when interrupts are disabled */
static void prioritySet(os_hwi_handle hwi_num,
os_hwi_priority priority)
{
uint16_t index;
uint32_t priority_mask;
uint32_t *priority_reg_ptr;
uint32_t current_reg;
/* EPIC interrupt:
Figure out which IPL register it is in. There are four interrupts
per IPL register. */
index = (uint16_t)(hwi_num >> 2); /* /4 */
priority_reg_ptr = (uint32_t *)((g_dsp_plat_map->epic).p_ipl);
priority_reg_ptr += index;
/* Figure out what the priority mask looks like */
priority_mask = 0x000000FFUL << ((hwi_num & 0x0003) * 8);
/* For NMI priority, the IPL bits do not matter in the p_ipl */
/* register, only need to set the INC bit to NMI. */
if (priority == OS_HWI_PRIORITY_NMI)
priority = 0x80;
/* Set priority */
READ_UINT32(current_reg, *priority_reg_ptr);
current_reg &= (priority_mask ^ 0xFFFFFFFF);
/* Set priority to zeroed bits in IPL */
current_reg |= ((uint32_t)priority) << ((hwi_num & 0x0003) * 8);
WRITE_UINT32(*priority_reg_ptr,current_reg);
}
gboolean
mpeg_util_parse_sequence_hdr (MPEGSeqHdr * hdr, GstBuffer * buffer)
{
GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buffer);
guint8 dar_idx, par_idx;
guint8 load_intra_flag, load_non_intra_flag;
/* skip sync word */
if (!gst_bit_reader_skip (&reader, 8 * 4))
return FALSE;
/* resolution */
READ_UINT16 (&reader, hdr->width, 12);
READ_UINT16 (&reader, hdr->height, 12);
/* aspect ratio */
READ_UINT8 (&reader, dar_idx, 4);
set_par_from_dar (hdr, dar_idx);
/* framerate */
READ_UINT8 (&reader, par_idx, 4);
set_fps_from_code (hdr, par_idx);
/* bitrate */
READ_UINT32 (&reader, hdr->bitrate, 18);
if (!gst_bit_reader_skip (&reader, 1))
return FALSE;
/* VBV buffer size */
READ_UINT16 (&reader, hdr->vbv_buffer, 10);
/* constrained parameters flag */
READ_UINT8 (&reader, hdr->constrained_parameters_flag, 1);
/* intra quantizer matrix */
READ_UINT8 (&reader, load_intra_flag, 1);
if (load_intra_flag) {
gint i;
for (i = 0; i < 64; i++)
READ_UINT8 (&reader, hdr->intra_quantizer_matrix[mpeg_zigzag_8x8[i]], 8);
} else
memcpy (hdr->intra_quantizer_matrix, default_intra_quantizer_matrix, 64);
/* non intra quantizer matrix */
READ_UINT8 (&reader, load_non_intra_flag, 1);
if (load_non_intra_flag) {
gint i;
for (i = 0; i < 64; i++)
READ_UINT8 (&reader, hdr->non_intra_quantizer_matrix[mpeg_zigzag_8x8[i]],
8);
} else
memset (hdr->non_intra_quantizer_matrix, 16, 64);
return TRUE;
error:
GST_WARNING ("error parsing \"Sequence Header\"");
return FALSE;
}
void Lingo::c_call() {
Common::String name((char *)&(*g_lingo->_currentScript)[g_lingo->_pc]);
g_lingo->_pc += g_lingo->calcStringAlignment(name.c_str());
int nargs = READ_UINT32(&(*g_lingo->_currentScript)[g_lingo->_pc++]);
g_lingo->call(name, nargs);
}
uint32_t Transport::status()
{
uint8_t in[4];
command(Transport::GET_STATUS, NULL, 0, in, sizeof(in));
uint32_t status;
READ_UINT32(&in[0], status);
return status;
}
void Lingo::c_repeatwithcode(void) {
Datum d;
int savepc = g_lingo->_pc;
uint init = READ_UINT32(&(*g_lingo->_currentScript)[savepc]);
uint finish = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 1]);
uint body = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 2]);
int inc = (int32)READ_UINT32(&(*g_lingo->_currentScript)[savepc + 3]);
uint end = READ_UINT32(&(*g_lingo->_currentScript)[savepc + 4]);
Common::String countername((char *)&(*g_lingo->_currentScript)[savepc + 5]);
Symbol *counter = g_lingo->lookupVar(countername.c_str());
if (counter->type == CASTREF) {
error("Cast ref used as index: %s", countername.c_str());
}
g_lingo->execute(init + savepc - 1); /* condition */
d = g_lingo->pop();
d.toInt();
counter->u.i = d.u.i;
counter->type = INT;
while (true) {
g_lingo->execute(body + savepc - 1); /* body */
if (g_lingo->_returning)
break;
if (g_lingo->_exitRepeat) {
g_lingo->_exitRepeat = false;
break;
}
counter->u.i += inc;
g_lingo->execute(finish + savepc - 1); /* condition */
d = g_lingo->pop();
d.toInt();
if (counter->u.i == d.u.i + inc)
break;
}
if (!g_lingo->_returning)
g_lingo->_pc = end + savepc - 1; /* next stmt */
}
int
sftp_get_uint32(struct sftp_input *i, uint32_t *value)
{
uint8_t buf[4];
if (!GET_DATA(i, buf))
return 0;
*value = READ_UINT32(buf);
return 1;
}
uint32_t hwTimer32GlobalGet(soc_timer32_module_t module)
{
volatile uint32_t reg;
#ifdef HW_TIMER_ERROR_ASSERT
OS_ASSERT_COND(!(module > NUM_OF_HW_TIMER_32b_MODULES-1));
#endif
// Reading one of the counters in order to load the global timer
READ_UINT32(reg, soc_timer32_module[module].tmr[0].tmr_cntr);
return GET_UINT32(soc_timer32_module[module].tmr_glb);
}
int
parse_uint32(struct simple_buffer *buffer, uint32_t *result)
{
if (LEFT < 4)
return 0;
*result = READ_UINT32(HERE);
ADVANCE(4);
return 1;
}
static int
read_uint32(FILE *f, uint32_t *n)
{
uint8_t buf[4];
if (fread(buf, 1, sizeof(buf), f) != sizeof(buf))
return 0;
*n = READ_UINT32(buf);
return 1;
}
void Lingo::c_whencode() {
Datum d;
int start = g_lingo->_pc;
int end = READ_UINT32(&(*g_lingo->_currentScript)[start]);
Common::String eventname((char *)&(*g_lingo->_currentScript)[start]);
start += g_lingo->calcStringAlignment(eventname.c_str());
warning("STUB: c_whencode([%5d][%5d], %s)", start, end, eventname.c_str());
g_lingo->_pc = end;
}
bool osGpioDataRead(int gpio_num, int port)
{
uint32_t reg;
OS_ASSERT_COND(gpio_num < OS_NUM_OF_GPIO);
OS_ASSERT_COND(port <= OS_NUM_OF_GPIO_PORTS);
READ_UINT32(reg, g_dsp_pa_ccsr_map->gpio[gpio_num].gpdat);
if ((reg & (1 << (31-port))) == 0)
return 0;
else
return 1;
}
Uint32 dw_getPixel(SDL_Surface *s, Uint16 x, Uint16 y) {
assert(s);
assert(x < s->w && y < s->h);
Uint32 bpp = s->format->BytesPerPixel;
Uint8 *p = (Uint8 *)s->pixels + (y * s->pitch) + (x * bpp);
Uint32 pix;
switch (bpp) {
case 1: // b/w
return *p;
case 2: // 16 bit per pixel
return READ_UINT16(p);
case 3:
pix = p[0] << 24 | p[1] << 16 | p[0] << 0;
return READ_UINT32(&pix);
case 4:
return READ_UINT32(p);
default: // !?!?
return 0;
}
}
/* Returns 1 of all was well, 0 on error, and -1 on EOF */
int
sftp_read_packet(struct sftp_input *i)
{
uint8_t buf[4];
int bytesread = 0;
if (i->left) /* Unread data? */
{
uint8_t d;
while (i->left && /* Data remaining? */
0<sftp_get_data(i, 1, &d) /* Read OK? */
)
;
/* Now, there shouldn't be any more data remaining. Next time
* we're called, the next packet should be read (or we had an
* error and all data is not read, if that's the case, return
* error).
*/
if (i->left) /* i->left non-zero => sftp_get_data failed => error */
return -1;
return 0;
}
/* First, deallocate the strings. */
sftp_input_clear_strings(i);
while (bytesread < sizeof(buf))
{
int j = read(i->fd, buf+bytesread, sizeof(buf)-bytesread);
while(-1==j && EINTR==errno) /* Loop over EINTR */
j = read(i->fd, buf+bytesread, sizeof(buf)-bytesread);
if (-1==j) /* Not EINTR but a real error */
return -1;
if (j == 0)
/* EOF */
return bytesread ? 0 : -1;
bytesread += j;
}
i->left = READ_UINT32(buf); /* Store packet size */
return 1;
}
void Lingo::c_arraypush() {
Datum d;
inst v = (*g_lingo->_currentScript)[g_lingo->_pc++];
int arraySize = READ_UINT32(&v);
warning("STUB: c_arraypush()");
for (int i = 0; i < arraySize; i++)
g_lingo->pop();
d.u.i = arraySize;
d.type = INT;
g_lingo->push(d);
}
const SCENE_STRUC *GetSceneStruc(const byte *pStruc) {
if (TinselVersion == TINSEL_V2)
return (const SCENE_STRUC *)pStruc;
// Copy appropriate fields into tempStruc, and return a pointer to it
const byte *p = pStruc;
memset(&tempStruc, 0, sizeof(SCENE_STRUC));
tempStruc.numEntrance = READ_UINT32(p); p += sizeof(uint32);
tempStruc.numPoly = READ_UINT32(p); p += sizeof(uint32);
tempStruc.numTaggedActor = READ_UINT32(p); p += sizeof(uint32);
tempStruc.defRefer = READ_UINT32(p); p += sizeof(uint32);
tempStruc.hSceneScript = READ_UINT32(p); p += sizeof(uint32);
tempStruc.hEntrance = READ_UINT32(p); p += sizeof(uint32);
tempStruc.hPoly = READ_UINT32(p); p += sizeof(uint32);
tempStruc.hTaggedActor = READ_UINT32(p); p += sizeof(uint32);
return &tempStruc;
}
bool osGpioEventReadAndClear(int gpio_num, int port)
{
uint32_t reg;
OS_ASSERT_COND(gpio_num < OS_NUM_OF_GPIO);
OS_ASSERT_COND(port <= OS_NUM_OF_GPIO_PORTS);
READ_UINT32(reg, g_dsp_pa_ccsr_map->gpio[gpio_num].gpier);
if ((reg & (1 << (31-port))) == 0)
{
return 0;
}
else
{
CLEAR_LEVEL_INTERRUPT(g_dsp_pa_ccsr_map->gpio[gpio_num].gpier, 1<<(31-port));
return 1;
}
}
bool SaveConverter::swapDataEndian(byte *data, const byte *sizes, uint32 count) {
if (!data || !sizes || (count == 0))
return false;
while (count-- > 0) {
if (*sizes == 3) // 32bit value (3 additional bytes)
WRITE_UINT32(data, SWAP_BYTES_32(READ_UINT32(data)));
else if (*sizes == 1) // 16bit value (1 additional byte)
WRITE_UINT16(data, SWAP_BYTES_16(READ_UINT16(data)));
else if (*sizes != 0) // else, it has to be an 8bit value
return false;
count -= *sizes;
data += *sizes + 1;
sizes += *sizes + 1;
}
return true;
}
