ActionTAG* swf_ActionGet(TAG*tag)
{
U8 op = 1;
int length;
ActionTAG tmp;
ActionTAG*action = &tmp;
U8*data;
while(op)
{
action->next = (ActionTAG*)rfx_calloc(sizeof(ActionTAG));
action->next->prev = action;
action->next->next = 0;
action->next->parent = tmp.next;
action = action->next;
op = swf_GetU8(tag);
if(op<0x80)
length = 0;
else
length = swf_GetU16(tag);
if(length) {
data = (U8*)rfx_alloc(length);
swf_GetBlock(tag, data, length);
} else {
data = 0;
}
action->op = op;
action->len = length;
action->data = data;
}
return tmp.next;
}
int swf_FontExtract_DefineFontInfo(int id, SWFFONT *f, TAG *t)
{
uint16_t fid;
uint16_t maxcode;
uint8_t flags;
swf_SetTagPos(t, 0);
fid = swf_GetU16(t);
if (fid == id)
{
uint8_t l = swf_GetU8(t);
int i;
if (f->version > 1)
{
/* Especially with Flash MX, DefineFont2 may have FontInfo fields,
too. However, they only add little information to what's already
inside the DefineFont2 tag */
return id;
}
if (f->name)
free(f->name);
f->name = (uint8_t *) malloc(l + 1);
swf_GetBlock(t, f->name, l);
f->name[l] = 0;
flags = swf_GetU8(t);
if (flags & 2)
f->style |= FONT_STYLE_BOLD;
if (flags & 4)
f->style |= FONT_STYLE_ITALIC;
if (flags & 8)
f->encoding |= FONT_ENCODING_ANSI;
if (flags & 16)
f->encoding |= FONT_ENCODING_SHIFTJIS;
if (flags & 32)
f->encoding |= FONT_ENCODING_UNICODE;
if (t->id == ST_DEFINEFONTINFO2)
{
f->language = swf_GetU8(t);
}
f->glyph2ascii = (uint16_t *) malloc(sizeof(uint16_t) * f->numchars);
maxcode = 0;
for (i = 0; i < f->numchars; i++)
{
f->glyph2ascii[i] = ((flags & FF_WIDECODES) ? swf_GetU16(t) : swf_GetU8(t));
if (f->glyph2ascii[i] > maxcode)
maxcode = f->glyph2ascii[i];
}
maxcode++;
if (maxcode < 256)
maxcode = 256;
f->maxascii = maxcode;
f->ascii2glyph = (int *)malloc(sizeof(int) * maxcode);
memset(f->ascii2glyph, -1, sizeof(int) * maxcode);
for (i = 0; i < f->numchars; i++)
f->ascii2glyph[f->glyph2ascii[i]] = i;
}
return id;
}
int swf_FontExtract_DefineFont2(int id, SWFFONT *font, TAG *tag)
{
int t, glyphcount;
int maxcode;
int fid;
uint32_t offset_start;
uint32_t *offset;
uint8_t flags1, /*langcode, */namelen;
swf_SetTagPos(tag, 0);
font->version = tag->id == ST_DEFINEFONT3 ? 3 : 2;
fid = swf_GetU16(tag);
if (id && id != fid)
return id;
font->id = fid;
flags1 = swf_GetU8(tag);
/*langcode = */swf_GetU8(tag); //reserved flags
if (flags1 & 1)
font->style |= FONT_STYLE_BOLD;
if (flags1 & 2)
font->style |= FONT_STYLE_ITALIC;
if (flags1 & 16)
font->encoding |= FONT_ENCODING_ANSI;
if (flags1 & 32)
font->encoding |= FONT_ENCODING_UNICODE;
if (flags1 & 64)
font->encoding |= FONT_ENCODING_SHIFTJIS;
namelen = swf_GetU8(tag);
font->name = (uint8_t *) malloc(namelen + 1);
font->name[namelen] = 0;
swf_GetBlock(tag, font->name, namelen);
glyphcount = swf_GetU16(tag);
font->numchars = glyphcount;
font->glyph = (SWFGLYPH *) calloc(1, sizeof(SWFGLYPH) * glyphcount);
font->glyph2ascii = (uint16_t *) calloc(1, sizeof(uint16_t) * glyphcount);
offset = (uint32_t*)calloc(1, sizeof(uint32_t)*(glyphcount + 1));
offset_start = tag->pos;
if (flags1 & 8)
{ // wide offsets
for (t = 0; t < glyphcount; t++)
offset[t] = swf_GetU32(tag); //offset[t]
if (glyphcount) /* this _if_ is not in the specs */
offset[glyphcount] = swf_GetU32(tag); // fontcodeoffset
else
offset[glyphcount] = tag->pos;
} else
{
for (t = 0; t < glyphcount; t++)
offset[t] = swf_GetU16(tag); //offset[t]
if (glyphcount) /* this _if_ is not in the specs */
offset[glyphcount] = swf_GetU16(tag); // fontcodeoffset
else
offset[glyphcount] = tag->pos;
}
for (t = 0; t < glyphcount; t++)
{
swf_SetTagPos(tag, offset[t] + offset_start);
swf_GetSimpleShape(tag, &(font->glyph[t].shape));
}
if (glyphcount)
swf_SetTagPos(tag, offset[glyphcount] + offset_start);
free(offset);
maxcode = 0;
for (t = 0; t < glyphcount; t++)
{
int code;
if (flags1 & 4) // wide codes (always on for definefont3)
code = swf_GetU16(tag);
else
code = swf_GetU8(tag);
font->glyph2ascii[t] = code;
if (code > maxcode)
maxcode = code;
}
maxcode++;
if (maxcode < 256)
maxcode = 256;
font->maxascii = maxcode;
font->ascii2glyph = (int *) malloc(sizeof(int) * maxcode);
memset(font->ascii2glyph, -1, sizeof(int) * maxcode);
for (t = 0; t < glyphcount; t++)
{
font->ascii2glyph[font->glyph2ascii[t]] = t;
}
if (flags1 & 128)
{ // has layout
uint16_t kerningcount;
font->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
font->layout->ascent = swf_GetU16(tag);
font->layout->descent = swf_GetU16(tag);
font->layout->leading = swf_GetU16(tag);
for (t = 0; t < glyphcount; t++)
{
int16_t advance = swf_GetS16(tag);
font->glyph[t].advance = advance;
}
font->layout->bounds = (SRECT*)malloc(glyphcount * sizeof(SRECT));
for (t = 0; t < glyphcount; t++)
{
swf_ResetReadBits(tag);
swf_GetRect(tag, &font->layout->bounds[t]);
SRECT b = font->layout->bounds[t];
if ((b.xmin | b.xmax | b.ymin | b.ymax) == 0)
{
// recalculate bounding box
SHAPE2 *shape2 = swf_ShapeToShape2(font->glyph[t].shape);
font->layout->bounds[t] = swf_GetShapeBoundingBox(shape2);
swf_Shape2Free(shape2); free(shape2);
}
}
kerningcount = swf_GetU16(tag);
font->layout->kerningcount = kerningcount;
font->layout->kerning = (SWFKERNING *) malloc(sizeof(SWFKERNING) * kerningcount);
if (kerningcount)
{
font->layout->kerning = (SWFKERNING*)malloc(sizeof(*font->layout->kerning) * kerningcount);
for (t = 0; t < kerningcount; t++)
{
if (flags1 & 4)
{ // wide codes
font->layout->kerning[t].char1 = swf_GetU16(tag);
font->layout->kerning[t].char2 = swf_GetU16(tag);
} else
{
font->layout->kerning[t].char1 = swf_GetU8(tag);
font->layout->kerning[t].char2 = swf_GetU8(tag);
}
font->layout->kerning[t].adjustment = swf_GetS16(tag);
}
}
}
return font->id;
}
