lsr_dec.c

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

		case TAG_SVG_ATT_text_anchor: 
			GF_LSR_READ_INT(lsr, *(SVG_TextAnchor*)info.far_ptr, 2, "text-achor"); 
			break;
		case TAG_SVG_ATT_text_rendering: 
			GF_LSR_READ_INT(lsr, *(SVG_RenderingHint*)info.far_ptr, 3, "text-rendering"); 
			break;
	    case TAG_SVG_ATT_viewport_fill: 
			lsr_read_paint(lsr, info.far_ptr, "viewport-fill"); 
			break;
		case TAG_SVG_ATT_viewport_fill_opacity: 
			((SVG_Number*)info.far_ptr)->type = SVG_NUMBER_VALUE; 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "viewport-fill-opacity"); 
			break;
		case TAG_SVG_ATT_vector_effect: 
			GF_LSR_READ_INT(lsr, *(SVG_VectorEffect*)info.far_ptr, 4, "vector-effect"); 
			break;
	    case TAG_SVG_ATT_visibility: 
			GF_LSR_READ_INT(lsr, *(SVG_Visibility*)info.far_ptr, 2, "visibility"); 
			break;
		case TAG_SVG_ATT_requiredExtensions: 
			lsr_read_byte_align_string_list(lsr, *(GF_List**)info.far_ptr, "requiredExtensions", 1); 
			break;
	    case TAG_SVG_ATT_requiredFormats: 
			lsr_read_byte_align_string_list(lsr, *(GF_List**)info.far_ptr, "requiredFormats", 0); 
			break;
	    case TAG_SVG_ATT_requiredFeatures:
		{
			u32 j, fcount = lsr_read_vluimsbf5(lsr, "count");
			for (j=0; j<fcount; j++) {
				u32 fval;
				GF_LSR_READ_INT(lsr, fval, 6, "feature");
			}
		}
			break;
	    case TAG_SVG_ATT_systemLanguage: 
			lsr_read_byte_align_string_list(lsr, *(GF_List**)info.far_ptr, "systemLanguage", 0); 
			break;
	    case TAG_SVG_ATT_xml_base: 
			lsr_read_byte_align_string(lsr, &((XMLRI*)info.far_ptr)->string, "xml:base"); 
			((XMLRI*)info.far_ptr)->type = XMLRI_STRING;
			break;
	    case TAG_SVG_ATT_xml_lang: 
			lsr_read_byte_align_string(lsr, info.far_ptr, "xml:lang"); 
			break;
	    case TAG_SVG_ATT_xml_space: 
			GF_LSR_READ_INT(lsr, *(XML_Space*)info.far_ptr, 1, "xml:space"); 
			break;
		/*focusable*/
		case TAG_SVG_ATT_nav_next: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusNext"); break;
		case TAG_SVG_ATT_nav_up: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusNorth"); break;
		case TAG_SVG_ATT_nav_up_left: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusNorthEast"); break;
		case TAG_SVG_ATT_nav_up_right: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusNorthWest"); break;
		case TAG_SVG_ATT_nav_prev: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusPrev"); break;
		case TAG_SVG_ATT_nav_down: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusSouth"); break;
		case TAG_SVG_ATT_nav_down_left: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusSouthEast"); break;
		case TAG_SVG_ATT_nav_down_right: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusSouthWest"); break;
		case TAG_SVG_ATT_nav_left: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusEast"); break;
		case TAG_SVG_ATT_focusable:
			/*wrong !!*/
			GF_LSR_READ_INT(lsr, *(SVG_Focusable*)info.far_ptr, 2, "focusable"); 
			break;
		case TAG_SVG_ATT_nav_right: 
			lsr_read_focus(lsr, (SVG_Focus*)info.far_ptr, "focusWest"); 
			break;
		case TAG_SVG_ATT_transform: 
			lsr_read_matrix(lsr, info.far_ptr);
			break;
		case TAG_SVG_ATT_text_decoration: 
			/*FIXME ASAP*/
			assert(0);
			break;

     	case TAG_SVG_ATT_font_variant:
			GF_LSR_READ_INT(lsr, *(SVG_FontVariant*)info.far_ptr, 2, "font-variant"); 
			break;
		case TAG_SVG_ATT_font_family:
		{
			u32 flag;
			GF_LSR_READ_INT(lsr, flag, 1, "isInherit");
			if (flag) {
				((SVG_FontFamily*)info.far_ptr)->type = SVG_FONTFAMILY_INHERIT;
			} else {
				char *ft;
				((SVG_FontFamily*)info.far_ptr)->type = SVG_FONTFAMILY_VALUE;
				GF_LSR_READ_INT(lsr, flag, lsr->fontIndexBits, "fontIndex");
				ft = (char*)gf_list_get(lsr->font_table, flag);
				if (ft) ((SVG_FontFamily*)info.far_ptr)->value = strdup(ft);
			}
		}
			break;
		case TAG_SVG_ATT_font_size:
			lsr_read_fixed_16_8i(lsr, info.far_ptr, "fontSize"); 
			break;
		case TAG_SVG_ATT_font_style: 
			GF_LSR_READ_INT(lsr, *(SVG_FontStyle*)info.far_ptr, 3, "fontStyle"); 
			break;
		case TAG_SVG_ATT_font_weight: 
			GF_LSR_READ_INT(lsr, *(SVG_FontWeight*)info.far_ptr, 4, "fontWeight"); 
			break;
		case TAG_SVG_ATT_xlink_title: 
			lsr_read_byte_align_string(lsr, info.far_ptr, "xlink:title"); 
			break;		
		case TAG_SVG_ATT_xlink_type: 
			/*TODO FIXME*/
			GF_LSR_READ_INT(lsr, field_rare, 3, "xlink:type"); 
			break;
		case TAG_SVG_ATT_xlink_role: 
			lsr_read_any_uri(lsr, info.far_ptr, "xlink:role");  
			break;
		case TAG_SVG_ATT_xlink_arcrole: 
			lsr_read_any_uri(lsr, info.far_ptr, "xlink:arcrole");  
			break;
		case TAG_SVG_ATT_xlink_actuate: 
			/*TODO FIXME*/
			GF_LSR_READ_INT(lsr, field_rare, 2, "xlink:actuate"); 
			break;
		case TAG_SVG_ATT_xlink_show: 
			/*TODO FIXME*/
			GF_LSR_READ_INT(lsr, field_rare, 3, "xlink:show"); 
			break;
		case TAG_SVG_ATT_end: 
			lsr_read_smil_times(lsr, NULL, 0, info.far_ptr, "end", 0); 
			break;
		case TAG_SVG_ATT_max: lsr_read_duration_ex(lsr, NULL, 0, info.far_ptr, "min", 0); break;
		case TAG_SVG_ATT_min: lsr_read_duration_ex(lsr, NULL, 0, info.far_ptr, "min", 0); break;
		}
		if (lsr->last_error) break;
	}
}

#define lsr_read_rare(_a, _b) lsr_read_rare_full(_a, _b)

static void lsr_read_fill(GF_LASeRCodec *lsr, GF_Node *n)
{
	Bool has_fill;
	GF_LSR_READ_INT(lsr, has_fill, 1, "fill");
	if (has_fill) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_fill, 1, 0, &info);
		lsr_read_paint(lsr, info.far_ptr, "fill");
	}
}

static void lsr_read_stroke(GF_LASeRCodec *lsr, GF_Node *n)
{
	Bool has_stroke;
	GF_LSR_READ_INT(lsr, has_stroke, 1, "has_stroke");
	if (has_stroke) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_stroke, 1, 0, &info);
		lsr_read_paint(lsr, info.far_ptr, "stroke");
	}
}
static void lsr_read_href(GF_LASeRCodec *lsr, GF_Node *n)
{
	Bool has_href;
	GF_LSR_READ_INT(lsr, has_href, 1, "has_href");
	if (has_href) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_xlink_href, 1, 0, &info);
		lsr_read_any_uri(lsr, info.far_ptr, "href");
	}
}

static void lsr_read_accumulate(GF_LASeRCodec *lsr, GF_Node *n)
{
	Bool v;
	GF_LSR_READ_INT(lsr, v, 1, "has_accumulate");
	if (v) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_accumulate, 1, 0, &info);
		GF_LSR_READ_INT(lsr, *(SMIL_Accumulate*)info.far_ptr, 1, "accumulate");
	}
}
static void lsr_read_additive(GF_LASeRCodec *lsr, GF_Node *n)
{
	Bool v;
	GF_LSR_READ_INT(lsr, v, 1, "has_additive");
	if (v) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_additive, 1, 0, &info);
		GF_LSR_READ_INT(lsr, *(SMIL_Additive*)info.far_ptr, 1, "additive");
	}
}
static void lsr_read_calc_mode(GF_LASeRCodec *lsr, GF_Node *n)
{
	u32 v;
	/*SMIL_CALCMODE_LINEAR is default and 0 in our code*/
	GF_LSR_READ_INT(lsr, v, 1, "has_calcMode");
	if (v) {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_calcMode, 1, 0, &info);
		GF_LSR_READ_INT(lsr, *(SMIL_CalcMode*)info.far_ptr, 2, "calcMode");
	}
}

static void lsr_read_attribute_name_ex(GF_LASeRCodec *lsr, GF_Node *n, Bool skippable)
{
	u32 val = 1;
	if (skippable) {
		GF_LSR_READ_INT(lsr, val, 1, "hasAttributeName");
		if (!val) return;
	}

	GF_LSR_READ_INT(lsr, val, 1, "choice");
	if (val) {
		lsr_read_vluimsbf5(lsr, "item[i]");
		lsr_read_vluimsbf5(lsr, "item[i]");
		return;
	} else {
		GF_FieldInfo info;
		lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_attributeName, 1, 0, &info);
		GF_LSR_READ_INT(lsr, val, 8, "attributeType");

		/*translate type to attribute tag*/
		((SMIL_AttributeName*)info.far_ptr)->type = gf_lsr_anim_type_to_attribute(val);
	}
}
static void lsr_read_attribute_name(GF_LASeRCodec *lsr, GF_Node *n)
{
	lsr_read_attribute_name_ex(lsr, n, 1);
}

static void lsr_translate_anim_value(SMIL_AnimateValue *val, u32 coded_type)
{
	switch (val->type) {
	case SVG_StrokeDashArray_datatype:
	{
		SVG_StrokeDashArray *da;
		GF_List *l = (GF_List *)val->value;
		u32 i;
		GF_SAFEALLOC(da, SVG_StrokeDashArray);
		da->array.count = gf_list_count(l);
		if (!da->array.count) {
			da->type = SVG_STROKEDASHARRAY_INHERIT;
		} else {
			da->type = SVG_STROKEDASHARRAY_ARRAY;
			da->array.vals = (Fixed *) malloc(sizeof(Fixed)*da->array.count);
			for (i=0; i<da->array.count; i++) {
				Fixed *v = (Fixed *)gf_list_get(l, i);
				da->array.vals[i] = *v;
				free(v);
			}
			gf_list_del(l);
			val->value = da;
		}
	}
		break;
	case SVG_ViewBox_datatype:
	{
		SVG_ViewBox *vb;
		GF_List *l = (GF_List *)val->value;
		GF_SAFEALLOC(vb, SVG_ViewBox);
		if (gf_list_count(l)==4) {
			vb->x = * ((Fixed *)gf_list_get(l, 0));
			vb->y = * ((Fixed *)gf_list_get(l, 1));
			vb->width = * ((Fixed *)gf_list_get(l, 2));
			vb->height = * ((Fixed *)gf_list_get(l, 3));
		}
		while (gf_list_count(l)) {
			Fixed *v = (Fixed *)gf_list_last(l);
			free(v);
			gf_list_rem_last(l);
		}
		gf_list_del(l);
		val->value = vb;
	}
		break;
	case SVG_Coordinates_datatype:
	{
		SVG_Coordinates *coords;
		if (coded_type==1) {
			GF_List *l = gf_list_new();
			/*allocated value is already an SVG number*/
			gf_list_add(l, val->value);
			coords = (SVG_Coordinates*)malloc(sizeof(SVG_Coordinates));
			*coords = l;
			val->value = coords;
		} else if (coded_type==8) {
			GF_List *l = (GF_List *)val->value;
			u32 i, count = gf_list_count(l);
			for (i=0; i<count; i++) {
				SVG_Coordinate *c;
				Fixed *v = (Fixed *)gf_list_get(l, i);
				c = (SVG_Coordinate*)malloc(sizeof(SVG_Coordinate));
				c->type = SVG_NUMBER_VALUE;
				c->value = *v;
				free(v);
				gf_list_rem(l, i);
				gf_list_insert(l, c, i);
			}
			coords = (SVG_Coordinates*)malloc(sizeof(SVG_Coordinates));
			*coords = (GF_List *) val->value;
			val->value = coords;
		}
	}
		break;
	case SVG_Motion_datatype:
		if (coded_type==9) {
			GF_Matrix2D *mat;
			SVG_Point *pt = (SVG_Point *)val->value;
			GF_SAFEALLOC(mat, GF_Matrix2D);
			gf_mx2d_init(*mat);
			mat->m[2] = pt->x;
			mat->m[5] = pt->y;
			free(pt);
			val->value = mat;
		}
		break;
	}
}
static void lsr_translate_anim_values(SMIL_AnimateValues *val, u32 coded_type)
{
	u32 i, count;
	GF_List *list = val->values;
	count = gf_list_count(list);
	for (i=0; i<count; i++) {
		switch (val->type) {
		case SVG_StrokeDashArray_datatype:
		{
			SVG_StrokeDashArray *da;
			GF_List *l = (GF_List *)gf_list_get(list, i);
			u32 j;
			GF_SAFEALLOC(da, SVG_StrokeDashArray);
			da->array.count = gf_list_count(l);
			if (!da->array.count) {
				da->type = SVG_STROKEDASHARRAY_INHERIT;
			} else {
				da->type = SVG_STROKEDASHARRAY_ARRAY;
				da->array.vals = (Fixed *)malloc(sizeof(Fixed)*da->array.count);
				for (j=0; j<da->array.count; j++) {
					Fixed *v = (Fixed *)gf_list_get(l, j);
					da->array.vals[j] = *v;
					free(v);
				}
				gf_list_del(l);
				gf_list_rem(list, i);
				gf_list_insert(list, da, i);
			}
		}
			break;
		case SVG_ViewBox_datatype:
		{
			SVG_ViewBox *vb;
			GF_List *l = (GF_List *)gf_list_get(list, i);
			GF_SAFEALLOC(vb, SVG_ViewBox);
			if (gf_list_count(l)==4) {
				vb->x = * ((Fixed *)gf_list_get(l, 0));
				vb->y = * ((Fixed *)gf_list_get(l, 1));
				vb->width = * ((Fixed *)gf_list_get(l, 2));
				vb->height = * ((Fixed *)gf_list_get(l, 3));
			}
			while (gf_list_count(l)) {
				Fixed *v=(Fixed *)gf_list_last(l);
				free(v);
				gf_list_rem_last(l);
			}
			gf_list_del(l);
			gf_list_rem(list, i);
			gf_list_insert(list, vb, i);
		}
			break;
		case SVG_Coordinates_datatype:
		{
			SVG_Coordinates *coords;
			GF_List *l = (GF_List *)gf_list_get(list, i);
			u32 j, count2;
			count2 = gf_list_count(l);
			for (j=0; j<count2; j++) {
				SVG_Coordinate *c = (SVG_Coordinate *)malloc(sizeof(SVG_Coordinate));
				Fixed *v = (Fixed *)gf_list_get(l, j);
				c->type = SVG_NUMBER_VALUE;
				c->value = *v;
				gf_list_rem(l, j);
				gf_list_insert(l, c, j);
				free(v);
			}
		
			coords = (SVG_Coordinates*)malloc(sizeof(SVG_Coordinates));
			*coords = l;
			gf_list_rem(list, i);
			gf_list_insert(list, coords, i);
		}
			break;

		case SVG_Motion_datatype:
			if (coded_type==9) {
				GF_Matrix2D *m = (GF_Matrix2D *)malloc(sizeof(GF_Matrix2D ));
				GF_Point2D *pt = (GF_Point2D *)gf_list_get(list, i);
				gf_mx2d_init(*m);
				m->m[2] = pt->x;
				m->m[5] = pt->y;
				gf_list_rem(list, i);
				gf_list_insert(list, m, i);
				free(pt);
			}
			break;
		}
	}

}

static Bool lsr_init_smil_times(GF_LASeRCodec *lsr, SVG_Element *anim, GF_List *times, SVG_Element *parent)
{
	u32 i, count;
	count = gf_list_count(times);
	for (i=0; i<count; i++) {
		SMIL_Time *t = (SMIL_Time *)gf_list_get(times, i);
		if (t->type==GF_SMIL_TIME_EVENT) {
			if (t->element_id) {
				if (t->element_id[0]=='N') {
					t->element = gf_sg_find_node(lsr->sg, atoi(t->element_id+1) + 1);
				} else {
					t->element = gf_sg_find_node_by_name(lsr->sg, t->element_id);
				}
				if (!t->element) return 0;
				free(t->element_id);
				t->element_id = NULL;
			} 
			else if (!t->element) {
				if (t->event.parameter && (t->event.type==GF_EVENT_KEYDOWN) ) {
					t->element = lsr->sg->RootNode ? lsr->sg->RootNode : lsr->current_root;
				} else {
					t->element = (GF_Node*)parent;
				}
			}
		}
	}
	return 1;
}

static Bool lsr_setup_smil_anim(GF_LASeRCodec *lsr, SVG_Element *anim, SVG_Element *anim_parent)
{
	GF_FieldInfo info;
	u32 coded_type, not_res;
	GF_Node *target;
	Bool is_animateMotion, is_animateTransform;
	XMLRI *xlink;
	SMIL_AttributeName *name = NULL;
	SMIL_AnimateValue *value;

	/*setup smil events*/