lsr_enc.c

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

				if (!stricmp(ext, "Animation")) { vals[tot_count] = 0; tot_count++; }
				else if (!stricmp(ext, "Audio")) { vals[tot_count] = 1; tot_count++; }
				else if (!stricmp(ext, "ComposedVideo")) { vals[tot_count] = 2; tot_count++; }
				else if (!stricmp(ext, "ConditionalProcessing")) { vals[tot_count] = 3; tot_count++; }
				else if (!stricmp(ext, "ConditionalProcessingAttribute")) { vals[tot_count] = 4; tot_count++; }
				else if (!stricmp(ext, "CoreAttribute")) { vals[tot_count] = 5; tot_count++; }
				else if (!stricmp(ext, "Extensibility")) { vals[tot_count] = 6; tot_count++; }
				else if (!stricmp(ext, "ExternalResourcesRequired")) { vals[tot_count] = 7; tot_count++; }
				else if (!stricmp(ext, "Font")) { vals[tot_count] = 8; tot_count++; }
				else if (!stricmp(ext, "Gradient")) { vals[tot_count] = 9; tot_count++; }
				else if (!stricmp(ext, "GraphicsAttribute")) { vals[tot_count] = 10; tot_count++; }
				else if (!stricmp(ext, "Handler")) { vals[tot_count] = 11; tot_count++; }
				else if (!stricmp(ext, "Hyperlinking")) { vals[tot_count] = 12; tot_count++; }
				else if (!stricmp(ext, "Image")) { vals[tot_count] = 13; tot_count++; }
				else if (!stricmp(ext, "OpacityAttribute")) { vals[tot_count] = 14; tot_count++; }
				else if (!stricmp(ext, "PaintAttribute")) { vals[tot_count] = 15; tot_count++; }
				else if (!stricmp(ext, "Prefetch")) { vals[tot_count] = 16; tot_count++; }
				else if (!stricmp(ext, "SVG")) { vals[tot_count] = 17; tot_count++; }
				else if (!stricmp(ext, "SVG-animation")) { vals[tot_count] = 18; tot_count++; }
				else if (!stricmp(ext, "SVG-dynamic")) { vals[tot_count] = 19; tot_count++; }
				else if (!stricmp(ext, "SVG-static")) { vals[tot_count] = 20; tot_count++; }
				else if (!stricmp(ext, "SVGDOM")) { vals[tot_count] = 21; tot_count++; }
				else if (!stricmp(ext, "SVGDOM-animation")) { vals[tot_count] = 22; tot_count++; }
				else if (!stricmp(ext, "SVGDOM-dynamic")) { vals[tot_count] = 23; tot_count++; }
				else if (!stricmp(ext, "SVGDOM-static")) { vals[tot_count] = 24; tot_count++; }
				else if (!stricmp(ext, "Script")) { vals[tot_count] = 25; tot_count++; }
				else if (!stricmp(ext, "Shape")) { vals[tot_count] = 26; tot_count++; }
				else if (!stricmp(ext, "SolidColor")) { vals[tot_count] = 27; tot_count++; }
				else if (!stricmp(ext, "Structure")) { vals[tot_count] = 28; tot_count++; }
				else if (!stricmp(ext, "Text")) { vals[tot_count] = 29; tot_count++; }
				else if (!stricmp(ext, "TimedAnimation")) { vals[tot_count] = 30; tot_count++; }
				else if (!stricmp(ext, "TransformedVideo")) { vals[tot_count] = 31; tot_count++; }
				else if (!stricmp(ext, "Video")) { vals[tot_count] = 32; tot_count++; }
				else if (!stricmp(ext, "XlinkAttribute")) { vals[tot_count] = 33; tot_count++; }
			}
			lsr_write_vluimsbf5(lsr, tot_count, "len");
	        for (j=0; j<tot_count; j++) {
				GF_LSR_WRITE_INT(lsr, vals[j], 6, "feature");
			}
			free(vals);
		}
			break;

	    case TAG_SVG_ATT_systemLanguage: 
			lsr_write_byte_align_string_list(lsr, *(GF_List **)att->data, "systemLanguage", 0); 
			break;
	    case TAG_SVG_ATT_xml_base: lsr_write_byte_align_string(lsr, ((XMLRI*)att->data)->string, "xml:base"); break;
	    case TAG_SVG_ATT_xml_lang: lsr_write_byte_align_string(lsr, *(SVG_String *)att->data, "xml:lang"); break;
	    case TAG_SVG_ATT_xml_space: GF_LSR_WRITE_INT(lsr, *(XML_Space *)att->data, 1, "xml:space"); break;
		case TAG_SVG_ATT_nav_next: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusNext"); break;
		case TAG_SVG_ATT_nav_up: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusNorth"); break;
		case TAG_SVG_ATT_nav_up_left: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusNorthEast"); break;
		case TAG_SVG_ATT_nav_up_right: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusNorthWest"); break;
		case TAG_SVG_ATT_nav_prev: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusPrev"); break;
		case TAG_SVG_ATT_nav_down: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusSouth"); break;
		case TAG_SVG_ATT_nav_down_left: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusSouthEast"); break;
		case TAG_SVG_ATT_nav_down_right: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusSouthWest"); break;
		case TAG_SVG_ATT_nav_right: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusWest"); break;
		case TAG_SVG_ATT_nav_left: lsr_write_focus(lsr, (SVG_Focus*)att->data, "focusEast"); break;

     	case TAG_SVG_ATT_font_variant: GF_LSR_WRITE_INT(lsr, *(SVG_FontVariant *)att->data, 2, "font-variant"); break;
		case TAG_SVG_ATT_font_family:
		{
			s32 idx = lsr_get_font_index(lsr, (SVG_FontFamily*)att->data);
			if (idx<0) {
				GF_LSR_WRITE_INT(lsr, 1, 1, "isInherit");
			} else {
				GF_LSR_WRITE_INT(lsr, 0, 1, "isInherit");
				GF_LSR_WRITE_INT(lsr, idx, lsr->fontIndexBits, "fontIndex");
			}
		}
			break;
		case TAG_SVG_ATT_font_size: lsr_write_fixed_16_8i(lsr, (SVG_Number*)att->data, "fontSize"); break;
		case TAG_SVG_ATT_font_style: GF_LSR_WRITE_INT(lsr, *((SVG_FontStyle *)att->data), 3, "fontStyle"); break;
		case TAG_SVG_ATT_font_weight: GF_LSR_WRITE_INT(lsr, *((SVG_FontWeight *)att->data), 4, "fontWeight"); break;

		case TAG_SVG_ATT_xlink_title: lsr_write_byte_align_string(lsr, *(SVG_String *)att->data, "xlink:title"); break;
		/*TODO FIXME*/
		case TAG_SVG_ATT_xlink_type: GF_LSR_WRITE_INT(lsr, 0, 3, "xlink:type"); break;
		case TAG_SVG_ATT_xlink_role: lsr_write_any_uri(lsr, (XMLRI*)att->data, "xlink:role"); break;
		case TAG_SVG_ATT_xlink_arcrole: lsr_write_any_uri(lsr, (XMLRI*)att->data, "xlink:arcrole"); break;
		/*TODO FIXME*/
		case TAG_SVG_ATT_xlink_actuate: GF_LSR_WRITE_INT(lsr, 0, 2, "xlink:actuate"); break;
		case TAG_SVG_ATT_xlink_show: GF_LSR_WRITE_INT(lsr, 0, 3, "xlink:show"); break;
		case TAG_SVG_ATT_end: lsr_write_smil_times(lsr, (GF_List **)att->data, "end", 0); break;
		case TAG_SVG_ATT_min: lsr_write_duration_ex(lsr, (SMIL_Duration*)att->data, "min", 0); break;
		case TAG_SVG_ATT_max: lsr_write_duration_ex(lsr, (SMIL_Duration*)att->data, "max", 0); break;
		case TAG_SVG_ATT_transform: lsr_write_matrix(lsr, (SVG_Transform*)att->data); break;

		}
		att = att->next;
	}
}

static void lsr_write_fill(GF_LASeRCodec *lsr, SVG_Element *n, SVGAllAttributes *atts)
{
	if (atts->fill) {
		GF_LSR_WRITE_INT(lsr, 1, 1, "fill");
		lsr_write_paint(lsr, atts->fill, "fill");
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "fill");
	}
}

static void lsr_write_stroke(GF_LASeRCodec *lsr, SVG_Element *n, SVGAllAttributes *atts)
{
	if (atts->stroke) {
		GF_LSR_WRITE_INT(lsr, 1, 1, "has_stroke");
		lsr_write_paint(lsr, atts->stroke, "stroke");
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "has_stroke");
	}
}
static void lsr_write_href(GF_LASeRCodec *lsr, XMLRI *iri)
{
	Bool has_href = iri ? 1 : 0;
	if (iri) {
		if (iri->type==XMLRI_ELEMENTID) {
			if (!iri->target && iri->string) iri->target = (SVG_Element *)gf_sg_find_node_by_name(lsr->sg, iri->string+1);
			if (!iri->target || !gf_node_get_id((GF_Node *)iri->target)) has_href = 0;
		} 
		else if (iri->type==XMLRI_STREAMID) {
			if (!iri->lsr_stream_id) has_href = 0;
		}
		else if (!iri->string) has_href = 0;
	}

	GF_LSR_WRITE_INT(lsr, has_href, 1, "has_href");
	if (has_href) lsr_write_any_uri(lsr, iri, "href");
}

static void lsr_write_accumulate(GF_LASeRCodec *lsr, SMIL_Accumulate *accum_type)
{
	GF_LSR_WRITE_INT(lsr, accum_type ? 1 : 0, 1, "has_accumulate");
	if (accum_type) GF_LSR_WRITE_INT(lsr, *accum_type, 1, "accumulate");
}
static void lsr_write_additive(GF_LASeRCodec *lsr, SMIL_Additive *add_type)
{
	GF_LSR_WRITE_INT(lsr, add_type ? 1 : 0, 1, "has_additive");
	if (add_type) GF_LSR_WRITE_INT(lsr, *add_type, 1, "additive");
}
static void lsr_write_calc_mode(GF_LASeRCodec *lsr, u8 *calc_mode)
{

	/*SMIL_CALCMODE_LINEAR is default and 0 in our code*/
	GF_LSR_WRITE_INT(lsr, (!calc_mode || (*calc_mode==SMIL_CALCMODE_LINEAR)) ? 0 : 1, 1, "has_calcMode");
	if (calc_mode && (*calc_mode!=SMIL_CALCMODE_LINEAR)) {
		GF_LSR_WRITE_INT(lsr, *calc_mode, 2, "calcMode");
	}
}

static void lsr_write_animatable(GF_LASeRCodec *lsr, SMIL_AttributeName *anim_type, XMLRI *iri, const char *name)
{
	s32 a_type = -1;

	if (!anim_type || !iri || !iri->target) {
		GF_LSR_WRITE_INT(lsr, 0, 1, "hasAttributeName");
		return;
	}

	/*locate field - checkme, this may not work since anim is not setup...*/
	assert(anim_type->name || anim_type->tag);
	if (!anim_type->tag) anim_type->tag = gf_svg_get_attribute_tag(((GF_Node*)iri->target)->sgprivate->tag, anim_type->name);
	if (!anim_type->type) anim_type->type = gf_svg_get_attribute_type(anim_type->tag);
	a_type = gf_lsr_anim_type_from_attribute(anim_type->tag);
	if (a_type<0) {
		GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[LASeR] Unsupported attributeName %s\n", anim_type->name));
	}
	GF_LSR_WRITE_INT(lsr, 1, 1, "hasAttributeName");
	GF_LSR_WRITE_INT(lsr, 0, 1, "choice");
	GF_LSR_WRITE_INT(lsr, (u8) a_type, 8, "attributeType");
}

static void lsr_write_anim_fill(GF_LASeRCodec *lsr, u8 *animFreeze)
{
	GF_LSR_WRITE_INT(lsr, animFreeze ? 1 : 0, 1, "has_smil_fill");
	if (animFreeze) GF_LSR_WRITE_INT(lsr, *animFreeze, 1, "smil_fill");
}
static void lsr_write_anim_repeat(GF_LASeRCodec *lsr, SMIL_RepeatCount *repeat)
{
	GF_LSR_WRITE_INT(lsr, repeat ? 1 : 0, 1, "has_repeatCount");
	if (!repeat) return;

	if (repeat->type==SMIL_REPEATCOUNT_DEFINED) {
		GF_LSR_WRITE_INT(lsr, 0, 1, "repeatCount");
		lsr_write_fixed_16_8(lsr, repeat->count, "repeatCount");
	} else {
		GF_LSR_WRITE_INT(lsr, 1, 1, "repeatCount");
		/*enumeration indefinite{0}*/
	}
}
static void lsr_write_repeat_duration(GF_LASeRCodec *lsr, SMIL_Duration *smil)
{
	GF_LSR_WRITE_INT(lsr, smil ? 1 : 0, 1, "has_repeatDur");
	if (!smil) return;

	if (smil->type==SMIL_DURATION_DEFINED) {
		u32 now = (u32) (smil->clock_value * lsr->time_resolution);
		GF_LSR_WRITE_INT(lsr, 0, 1, "choice");
		lsr_write_vluimsbf5(lsr, now, "value");
	} else {
		GF_LSR_WRITE_INT(lsr, 1, 1, "choice");
		/*enumeration indefinite{0}*/
	}
}
static void lsr_write_anim_restart(GF_LASeRCodec *lsr, u8 *animRestart)
{
	GF_LSR_WRITE_INT(lsr, animRestart ? 1 : 0, 1, "has_restart");

	/*enumeration always{0} never{1} whenNotActive{2}*/
	if (animRestart) GF_LSR_WRITE_INT(lsr, *animRestart, 2, "restart");
}

static u32 svg_type_to_lsr_anim(u32 svg_type, u32 transform_type, GF_List *vals, void *a_val)
{
	switch (svg_type) {
	/*all string types*/
	case SVG_String_datatype:
		return 0;
	/*all length types*/
	case SVG_Number_datatype:
	case SVG_FontSize_datatype:
	case SVG_Length_datatype:
	case SVG_Coordinate_datatype:
		return 1;
	case SVG_PathData_datatype: 
		return 2;
	/*list of points*/
	case SMIL_KeyPoints_datatype: 
	case SVG_Points_datatype:
		return 3;
	/*all 0 - 1 types*/
/*
	case SVG_Opacity_datatype:
		return 4;
*/
	case SVG_Paint_datatype:
		return 5;
	/*all enums (u8) types*/ 
	case SVG_FillRule_datatype:
	case SVG_StrokeLineJoin_datatype:
	case SVG_StrokeLineCap_datatype:
	case SVG_FontStyle_datatype:
	case SVG_FontWeight_datatype:
	case SVG_FontVariant_datatype:
	case SVG_TextAnchor_datatype:
	case SVG_TransformType_datatype:
	case SVG_Display_datatype:
	case SVG_Visibility_datatype:
	case SVG_Overflow_datatype:
	case SVG_ZoomAndPan_datatype:
	case SVG_DisplayAlign_datatype:
	case SVG_TextAlign_datatype:
	case SVG_PointerEvents_datatype:
	case SVG_RenderingHint_datatype:
	case SVG_VectorEffect_datatype:
	case SVG_PlaybackOrder_datatype:
	case SVG_TimelineBegin_datatype:
		return 6;
	/*all list-of-int types*/ //return 7;
	/*all list-of-float types*/
	case SVG_StrokeDashArray_datatype:
	case SVG_ViewBox_datatype:
	case SVG_Coordinates_datatype:
		return 8;
	/*ID (u32) types*/ //return 10;
	case SVG_FontFamily_datatype:
		return 11;
	case XMLRI_datatype:
		return 12;
	case SVG_Motion_datatype:
		return 9;

	/*ARG LOOKS LIKE THE SPEC IS BROKEN HERE*/
	case SVG_Transform_Translate_datatype: return 9;
	case SVG_Transform_Scale_datatype: return 8;
	case SVG_Transform_Rotate_datatype: 
		if (vals) {
			u32 i=0;
			SVG_Point_Angle *pt;
			while ((pt = (SVG_Point_Angle *) gf_list_enum(vals, &i))) {
				if (pt->x || pt->y) return 8;
			}
		} else if (a_val) {
			SVG_Point_Angle *pt = (SVG_Point_Angle *) a_val;
			if (pt->x || pt->y) return 8;
		}
		return 1;
	case SVG_Transform_SkewX_datatype: return 1;
	case SVG_Transform_SkewY_datatype: return 1;
	//case SVG_Transform_datatype: return;
		/*FALL THROUH*/		
	default:
		return 255;
	}
}
static void lsr_write_coordinate(GF_LASeRCodec *lsr, Fixed val, Bool skipable, const char *name)
{
	if (skipable && !val) {
		GF_LSR_WRITE_INT(lsr, 0, 1, name);
	} else {
		u32 res = lsr_translate_coords(lsr, val, lsr->coord_bits);
		if (skipable) GF_LSR_WRITE_INT(lsr, 1, 1, name);
		GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, name);
	}
}

static void lsr_write_coordinate_ptr(GF_LASeRCodec *lsr, SVG_Coordinate *val, Bool skipable, const char *name)
{
	if (skipable && !val) {
		GF_LSR_WRITE_INT(lsr, 0, 1, name);
	} else {
		u32 res = lsr_translate_coords(lsr, val ? val->value : 0, lsr->coord_bits);
		if (skipable) GF_LSR_WRITE_INT(lsr, 1, 1, name);
		GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, name);
	}
}

static void lsr_write_an_anim_value(GF_LASeRCodec *lsr, void *val, u32 lsr_type, u32 svg_type, u32 transform_type, const char *name)
{
	if ((lsr_type==1) || (lsr_type==4)) {
		switch (svg_type) {
		case SVG_Transform_Rotate_datatype:
		case SVG_Transform_SkewX_datatype:
		case SVG_Transform_SkewY_datatype:
			GF_LSR_WRITE_INT(lsr, 0, 1, "escapeFlag");
			break;
		default:
		{
			SVG_Number  *n = (SVG_Number *) val;
			if (n->type != SVG_NUMBER_VALUE) {
				GF_LSR_WRITE_INT(lsr, 1, 1, "escapeFlag");
				GF_LSR_WRITE_INT(lsr, n->type, 2, "escapeEnum");
			} else {
				GF_LSR_WRITE_INT(lsr, 0, 1, "escapeFlag");
			}
		}
			break;
		}
	} else if (svg_type==SVG_StrokeDashArray_datatype) {
		SVG_StrokeDashArray *da = (SVG_StrokeDashArray *)val;
		if (da->type==SVG_STROKEDASHARRAY_INHERIT) {
			GF_LSR_WRITE_INT(lsr, 1, 1, "escapeFlag");
			GF_LSR_WRITE_INT(lsr, 0, 2, "escapeEnum");
		} else {
			GF_LSR_WRITE_INT(lsr, 0, 1, "escapeFlag");
		}
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "escapeFlag");
	}

    switch(lsr_type) {
    case 0: lsr_write_byte_align_string(lsr, *(DOM_String *)val, name); break;
    case 1: 
		if (svg_type==SVG_Transform_Rotate_datatype) {
			Fixed angle = ((SVG_Point_Angle *) val)->angle;
			angle = gf_muldiv(angle, INT2FIX(180), GF_PI);
			lsr_write_fixed_16_8(lsr, angle, name); 
		} else if ((svg_type==SVG_Transform_SkewX_datatype) || (svg_type==SVG_Transform_SkewY_datatype))  {
			lsr_write_fixed_16_8(lsr, *(Fixed *)val, name); 
		} else {
			lsr_write_fixed_16_8(lsr, ((SVG_Number *) val)->value, name); 
		}
		break;
    case 12: lsr_write_any_uri(lsr, (XMLRI*)val, name); break;
    case 2: lsr_write_path_type(lsr, (SVG_PathData*)val, name); break;
    case 3: lsr_write_point_sequence(lsr, (GF_List **)val, name); break;
    case 4: lsr_write_fixed_clamp(lsr, ((SVG_Number *) val)->value, name); break;
    case 5: lsr_write_paint(lsr, (SVG_Paint*)val, name); break;
    case 6: lsr_write_vluimsbf5(lsr, (u32) *(u8 *) val, name); break;
    case 10: lsr_write_vluimsbf5(lsr, *(u32 *) val, name); break;
    case 11: 
	{
		s32 idx = lsr_get_font_index(lsr, (SVG_FontFamily*)val);
		if (idx<0) {
			GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[LASeR] corrupted font table while encoding anim value\n"));
			idx=0;
		}
		lsr_write_vluimsbf5(lsr, idx, name);
	}
        break;
    case 7:
	{
		GF_List *l = *(GF_List **)val;
		u32 i, count = gf_list_count(l);