lsr_dec.c

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

		case TAG_SVG_ATT_stroke_opacity: 
		case TAG_SVG_ATT_stroke_width: 
		case TAG_SVG_ATT_text_align: 
		case TAG_SVG_ATT_text_anchor: 
		case TAG_SVG_ATT_text_rendering: 
		case TAG_SVG_ATT_vector_effect: 
		case TAG_SVG_ATT_viewport_fill: 
		case TAG_SVG_ATT_viewport_fill_opacity: 
		case TAG_SVG_ATT_visibility: 	
		/*and xml:_class*/
		case TAG_SVG_ATT__class: 
		case TAG_SVG_ATT_externalResourcesRequired:
			break;

		/*pathLength for path*/
		case TAG_SVG_ATT_pathLength:
			break;
		/*rx & ry for rect*/
		case TAG_SVG_ATT_rx:
		case TAG_SVG_ATT_ry:
			if (base->sgprivate->tag!=TAG_SVG_rect) {
				att = att->next;
				continue;
			}
			break;
		/*x & y for use*/
		case TAG_SVG_ATT_x:
		case TAG_SVG_ATT_y:
			if (base->sgprivate->tag!=TAG_SVG_use) {
				att = att->next;
				continue;
			}
			break;
		/*editable & rotate for text*/
		case TAG_SVG_ATT_editable:
		case TAG_SVG_ATT_rotate:
			if (base->sgprivate->tag!=TAG_SVG_text) {
				att = att->next;
				continue;
			}
			break;
		case TAG_SVG_ATT_transform:
			break;
		default:
			att = att->next;
			continue;
		}
		/*clone field*/
		e = gf_svg_get_attribute_by_tag((GF_Node*)elt, att->tag, 1, 0, &f_clone);
		if (e) goto err_exit;
		f_base.fieldIndex = att->tag;
		f_base.fieldType = att->data_type;
		f_base.far_ptr = att->data;
		e = gf_svg_attributes_copy(&f_clone, &f_base, 0);
		if (e) goto err_exit;

		if (is_fill && reset_fill) {
			SVG_Paint*p = (SVG_Paint*)f_clone.far_ptr;
			if (p->iri.string) free(p->iri.string);
			memset(p, 0, sizeof(SVG_Paint));
		}
		if (is_stroke && reset_stroke) {
			SVG_Paint*p = (SVG_Paint*)f_clone.far_ptr;
			if (p->iri.string) free(p->iri.string);
			memset(p, 0, sizeof(SVG_Paint));
		}
		att = att->next;
	}
	return;

err_exit:
	lsr->last_error = e;
}


static u32 lsr_to_dom_key(u32 lsr_k)
{
	switch (lsr_k) {
	case 0: return GF_KEY_STAR;
	case 1: return GF_KEY_0;
	case 2: return GF_KEY_1;
	case 3: return GF_KEY_2;
	case 4: return GF_KEY_3;
	case 5: return GF_KEY_4;
	case 6: return GF_KEY_5;
	case 7: return GF_KEY_6;
	case 8: return GF_KEY_7;
	case 9: return GF_KEY_8;
	case 10: return GF_KEY_9;
	case 12: return GF_KEY_DOWN;
	case 14: return GF_KEY_LEFT;
	case 16: return GF_KEY_RIGHT;
	case 20: return GF_KEY_UP;
	/*WHAT IS ANY_KEY (11) ??*/
	case 13: return GF_KEY_ENTER;
	case 15: return GF_KEY_ESCAPE;
	case 17: return GF_KEY_NUMBER;
	case 18: return GF_KEY_CELL_SOFT1;
	case 19: return GF_KEY_CELL_SOFT2;
	default:
		/*use '*' by default ... */
		return 0;
	}
}

static void lsr_read_event_type(GF_LASeRCodec *lsr, XMLEV_Event *evtType)
{
	u32 flag;
	GF_LSR_READ_INT(lsr, flag, 1, "choice");
	if (!flag) {
		char *evtName, *sep;
		evtName = NULL;
		lsr_read_byte_align_string(lsr, &evtName, "evtString");
		evtType->type = evtType->parameter = 0;
		if (evtName) {
			sep = strchr(evtName, '(');
			if (sep) {
				char *param;
				sep[0] = 0;
				evtType->type = gf_dom_event_type_by_name(evtName);
				sep[0] = '(';
				param = sep+1;
				sep = strchr(evtName, ')');
				if (sep) sep[0]=0;
				if (evtType->type==GF_EVENT_REPEAT) {
					evtType->parameter = atoi(param);
				} else {
					evtType->parameter = gf_dom_get_key_type(param);
				}
			} else {
				evtType->type = gf_dom_event_type_by_name(evtName);
			}
			free(evtName);
		}
	} else {
		evtType->parameter = 0;
		GF_LSR_READ_INT(lsr, flag, 6, "event");
		switch (flag) {
		case LSR_EVT_abort: evtType->type = GF_EVENT_ABORT; break;
		case LSR_EVT_accessKey: evtType->type = GF_EVENT_KEYDOWN; break;
		case LSR_EVT_activate: evtType->type = GF_EVENT_ACTIVATE; break;
		case LSR_EVT_activatedEvent: evtType->type = GF_EVENT_ACTIVATED; break;
		case LSR_EVT_beginEvent: evtType->type = GF_EVENT_BEGIN_EVENT; break;
		case LSR_EVT_click: evtType->type = GF_EVENT_CLICK; break;
		case LSR_EVT_deactivatedEvent: evtType->type = GF_EVENT_DEACTIVATED; break;
		case LSR_EVT_endEvent: evtType->type = GF_EVENT_END_EVENT; break;
		case LSR_EVT_error: evtType->type = GF_EVENT_ERROR; break;
		case LSR_EVT_executionTime: evtType->type = GF_EVENT_EXECUTION_TIME; break;
		case LSR_EVT_focusin: evtType->type = GF_EVENT_FOCUSIN; break;
		case LSR_EVT_focusout: evtType->type = GF_EVENT_FOCUSOUT; break;
		case LSR_EVT_keydown: evtType->type = GF_EVENT_KEYDOWN; break;
		case LSR_EVT_keyup: evtType->type = GF_EVENT_KEYUP; break;
		case LSR_EVT_load: evtType->type = GF_EVENT_LOAD; break;
		case LSR_EVT_longAccessKey: evtType->type = GF_EVENT_LONGKEYPRESS; break;
		case LSR_EVT_mousedown: evtType->type = GF_EVENT_MOUSEDOWN; break;
		case LSR_EVT_mousemove: evtType->type = GF_EVENT_MOUSEMOVE; break;
		case LSR_EVT_mouseout: evtType->type = GF_EVENT_MOUSEOUT; break;
		case LSR_EVT_mouseover: evtType->type = GF_EVENT_MOUSEOVER; break;
		case LSR_EVT_mouseup: evtType->type = GF_EVENT_MOUSEUP; break;
		case LSR_EVT_pause: evtType->type = GF_EVENT_PAUSE; break;
		case LSR_EVT_pausedEvent: evtType->type = GF_EVENT_PAUSED_EVENT; break;
		case LSR_EVT_play: evtType->type = GF_EVENT_PLAY; break;
		case LSR_EVT_repeatEvent: evtType->type = GF_EVENT_REPEAT_EVENT; break;
		case LSR_EVT_repeatKey: evtType->type = GF_EVENT_REPEAT_KEY; break;
		case LSR_EVT_resize: evtType->type = GF_EVENT_RESIZE; break;
		case LSR_EVT_resumedEvent: evtType->type = GF_EVENT_RESUME_EVENT; break;
		case LSR_EVT_scroll: evtType->type = GF_EVENT_SCROLL; break;
		case LSR_EVT_shortAccessKey: evtType->type = GF_EVENT_SHORT_ACCESSKEY; break;
		case LSR_EVT_textinput: evtType->type = GF_EVENT_TEXTINPUT; break;
		case LSR_EVT_unload: evtType->type = GF_EVENT_UNLOAD; break;
		case LSR_EVT_zoom: evtType->type = GF_EVENT_ZOOM; break;
		default:
			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[LASeR] Undefined LASeR event %d\n", flag));
			break;
		}
		switch (flag) {
		case LSR_EVT_accessKey:
		case LSR_EVT_longAccessKey:
		case LSR_EVT_repeatKey:
		case LSR_EVT_shortAccessKey:
			evtType->parameter = lsr_read_vluimsbf5(lsr, "keyCode");
			evtType->parameter  = lsr_to_dom_key(evtType->parameter);
			break;
		}
	}
}

static SMIL_Time *lsr_read_smil_time(GF_LASeRCodec *lsr, GF_Node *n)
{
	SMIL_Time *t;
	u32 val;

	GF_SAFEALLOC(t, SMIL_Time);
	t->type = GF_SMIL_TIME_CLOCK;

	GF_LSR_READ_INT(lsr, val, 1, "hasEvent");
	if (val) {
		t->type = GF_SMIL_TIME_EVENT;
		GF_LSR_READ_INT(lsr, val, 1, "hasIdentifier");
		if (val) {
			XMLRI iri;
			iri.type = 0xFF;
			iri.string = NULL;
			lsr_read_codec_IDREF(lsr, &iri, "idref");
			gf_svg_unregister_iri(lsr->sg, &iri);
			if (iri.string) {
				t->element_id = iri.string;
			} else {
				t->element = (GF_Node *)iri.target;
			}
		}
		lsr_read_event_type(lsr, &t->event);
		if (t->event.type==GF_EVENT_EXECUTION_TIME) {
			t->type = GF_SMIL_TIME_CLOCK;
			t->clock = gf_node_get_scene_time(n);
		}
	}
	GF_LSR_READ_INT(lsr, val, 1, "hasClock");
	if (val) {
		u32 now;
		GF_LSR_READ_INT(lsr, val, 1, "sign");
		now = lsr_read_vluimsbf5(lsr, "value");
		t->clock = now;
		t->clock /= lsr->time_resolution;
		if (val) t->clock *= -1;
	}
	return t;
}

static void lsr_read_smil_times(GF_LASeRCodec *lsr, GF_Node *n, u32 tag, SMIL_Times *times, const char *name, Bool skipable)
{
	GF_FieldInfo info;
	SMIL_Time *v;
	u32 val, i, count;

	if (skipable) {
		GF_LSR_READ_INT(lsr, val, 1, name);
		if (!val) return;
	}
	if (!times) {
		lsr->last_error = gf_svg_get_attribute_by_tag(n, tag, 1, 0, &info);
		times = (SMIL_Times*)info.far_ptr;
	}

	while (gf_list_count(*times)) {
		v = (SMIL_Time *)gf_list_last(*times);
		gf_list_rem_last(*times);
		if (v->element_id) free(v->element_id);
		free(v);
	}

	GF_LSR_READ_INT(lsr, val, 1, "choice");
	if (val) {
		GF_SAFEALLOC(v, SMIL_Time);
		v->type = GF_SMIL_TIME_INDEFINITE;
		gf_list_add(*times, v);
		return;
	}
	count = lsr_read_vluimsbf5(lsr, "count");
	for (i=0; i<count; i++) {
		v = lsr_read_smil_time(lsr, n);
		gf_list_add(*times, v);
	} 
}

static void lsr_read_duration_ex(GF_LASeRCodec *lsr, GF_Node *n, u32 tag, SMIL_Duration *smil, const char *name, Bool skipable)
{
	GF_FieldInfo info;
	u32 val = 1;

	if (skipable) {
		GF_LSR_READ_INT(lsr, val, 1, name);
		if (!val) return;
	}
	if (!smil) {
		lsr->last_error = gf_svg_get_attribute_by_tag(n, tag, 1, 0, &info);
		if (lsr->last_error) return;
		smil = (SMIL_Duration *)info.far_ptr;
	}
	smil->type = 0;

	GF_LSR_READ_INT(lsr, val, 1, "choice");
	if (val) {
		GF_LSR_READ_INT(lsr, smil->type, 2, "time");
	} else {
		Bool sign;
		u32 now;
		GF_LSR_READ_INT(lsr, sign, 1, "sign");
		now = lsr_read_vluimsbf5(lsr, "value");
		smil->clock_value = now;
		smil->clock_value /= lsr->time_resolution;
		if (sign) smil->clock_value *= -1; 
		smil->type = SMIL_DURATION_DEFINED;
	}
}
static void lsr_read_duration(GF_LASeRCodec *lsr, GF_Node *n)
{
	lsr_read_duration_ex(lsr, n, TAG_SVG_ATT_dur, NULL, "dur", 1);
}
/*TODO Add decent error checking...*/
static void lsr_read_rare_full(GF_LASeRCodec *lsr, GF_Node *n)
{
	GF_FieldInfo info;
	u32 i, nb_rare, field_rare;
	s32 field_tag;

	GF_LSR_READ_INT(lsr, nb_rare, 1, "has_rare");
	if (!nb_rare) return;
	GF_LSR_READ_INT(lsr, nb_rare, 6, "nbOfAttributes");

	for (i=0; i<nb_rare; i++) {
		GF_LSR_READ_INT(lsr, field_rare, 6, "attributeRARE");

		/*lsr extend*/
		if (field_rare==49) {
			u32 extID, len, j;
			while (1) {
				GF_LSR_READ_INT(lsr, extID, lsr->info->cfg.extensionIDBits, "extensionID");
				len = lsr_read_vluimsbf5(lsr, "len");
				if (extID==2) {
					GF_LSR_READ_INT(lsr, len, 2, "nbOfAttributes");
					for (j=0; j<len; j++) {
						GF_LSR_READ_INT(lsr, extID, 3, "attributeRARE");
						switch (extID) {
						case 0:
							lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_syncMaster, 1, 0, &info);
							GF_LSR_READ_INT(lsr, *(SVG_Boolean *)info.far_ptr, 1, "syncMaster");
							break;
						case 1:
							lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_focusHighlight, 1, 0, &info);
							GF_LSR_READ_INT(lsr, *(SVG_FocusHighlight *)info.far_ptr, 2, "focusHighlight");
							break;
						case 2:
							lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_initialVisibility, 1, 0, &info);
							GF_LSR_READ_INT(lsr, *(SVG_InitialVisibility *)info.far_ptr, 2, "initialVisibility");
							break;
						case 3:
							lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_fullscreen, 1, 0, &info);
							GF_LSR_READ_INT(lsr, *(SVG_Boolean *)info.far_ptr, 1, "fullscreen");
							break;
						case 4:
							lsr->last_error = gf_svg_get_attribute_by_tag(n, TAG_SVG_ATT_requiredFonts, 1, 0, &info);
							lsr_read_byte_align_string(lsr, info.far_ptr, "requiredFonts");
							break;
						}
					}
				} else {
					gf_bs_read_int(lsr->bs, len);
				}
				GF_LSR_READ_INT(lsr, extID, 1, "hasNextExtension");
				if (!extID) break;
			}
			continue;
		}
		field_tag = gf_lsr_rare_type_to_attribute(field_rare);
		if (field_tag==-1) {
			return;
		}
		lsr->last_error = gf_svg_get_attribute_by_tag(n, field_tag, 1, 0, &info);
		if (!info.far_ptr) lsr->last_error = GF_NOT_SUPPORTED;
		if (lsr->last_error) return;

		switch (field_tag) {
		case TAG_SVG_ATT__class: 
			lsr_read_byte_align_string(lsr, info.far_ptr, "class"); 
			break;
		/*properties*/
		case TAG_SVG_ATT_audio_level: 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "audio-level"); 
			break;
	    case TAG_SVG_ATT_color: 
			lsr_read_paint(lsr, (SVG_Paint *)info.far_ptr, "color"); 
			break;
		case TAG_SVG_ATT_color_rendering: 
			GF_LSR_READ_INT(lsr, *(SVG_RenderingHint*)info.far_ptr, 2, "color-rendering"); 
			break;
		case TAG_SVG_ATT_display: 
			GF_LSR_READ_INT(lsr, *(SVG_Display*)info.far_ptr, 5, "display"); 
			break;
	    case TAG_SVG_ATT_display_align: 
			GF_LSR_READ_INT(lsr, *(SVG_DisplayAlign*)info.far_ptr, 3, "display-align"); break;
		case TAG_SVG_ATT_fill_opacity: 
			((SVG_Number*)info.far_ptr)->type = SVG_NUMBER_VALUE; 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "fill-opacity"); 
			break;
	    case TAG_SVG_ATT_fill_rule: 
			GF_LSR_READ_INT(lsr, *(SVG_FillRule*)info.far_ptr, 2, "fill-rule"); 
			break;
		case TAG_SVG_ATT_image_rendering: 
			GF_LSR_READ_INT(lsr, *(SVG_RenderingHint*)info.far_ptr, 2, "image-rendering"); 
			break;
		case TAG_SVG_ATT_line_increment: 
			lsr_read_line_increment_type(lsr, info.far_ptr, "line-increment"); 
			break;
	    case TAG_SVG_ATT_pointer_events: 
			GF_LSR_READ_INT(lsr, *(SVG_PointerEvents*)info.far_ptr, 4, "pointer-events"); 
			break;
		case TAG_SVG_ATT_shape_rendering: 
			GF_LSR_READ_INT(lsr, *(SVG_RenderingHint*)info.far_ptr, 3, "shape-rendering"); 
			break;
	    case TAG_SVG_ATT_solid_color: 
			lsr_read_paint(lsr, info.far_ptr, "solid-color"); 
			break;
		case TAG_SVG_ATT_solid_opacity: 
			((SVG_Number*)info.far_ptr)->type = SVG_NUMBER_VALUE; 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "solid-opacity"); 
			break;
	    case TAG_SVG_ATT_stop_color: 
			lsr_read_paint(lsr, info.far_ptr, "stop-color"); 
			break;
		case TAG_SVG_ATT_stop_opacity: 
			((SVG_Number*)info.far_ptr)->type = SVG_NUMBER_VALUE; 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "stop-opacity"); 
			break;
		case TAG_SVG_ATT_stroke_dasharray:  
		{
			u32 j, flag;
			SVG_StrokeDashArray *da = (SVG_StrokeDashArray *)info.far_ptr;
			GF_LSR_READ_INT(lsr, flag, 1, "dashArray");
			if (flag) {
				da->type=SVG_STROKEDASHARRAY_INHERIT;
			} else {
				da->type=SVG_STROKEDASHARRAY_ARRAY;
				da->array.count = lsr_read_vluimsbf5(lsr, "len");
				da->array.vals = (Fixed*)malloc(sizeof(Fixed)*da->array.count);
		        for (j=0; j<da->array.count; j++) {
		            da->array.vals[j] = lsr_read_fixed_16_8(lsr, "dash");
				}
			}
		}
			break;
		case TAG_SVG_ATT_stroke_dashoffset:
			lsr_read_fixed_16_8i(lsr, info.far_ptr, "dashOffset"); 
			break;

		case TAG_SVG_ATT_stroke_linecap: 
			GF_LSR_READ_INT(lsr, *(SVG_StrokeLineCap*)info.far_ptr, 2, "stroke-linecap"); 
			break;
		case TAG_SVG_ATT_stroke_linejoin: 
			GF_LSR_READ_INT(lsr, *(SVG_StrokeLineJoin*)info.far_ptr, 2, "stroke-linejoin"); 
			break;
		case TAG_SVG_ATT_stroke_miterlimit: 
			lsr_read_fixed_16_8i(lsr, info.far_ptr, "miterLimit"); 
			break;
		case TAG_SVG_ATT_stroke_opacity: 
			((SVG_Number*)info.far_ptr)->type = SVG_NUMBER_VALUE; 
			((SVG_Number*)info.far_ptr)->value = lsr_read_fixed_clamp(lsr, "stroke-opacity"); 
			break;
		case TAG_SVG_ATT_stroke_width: 
			lsr_read_fixed_16_8i(lsr, info.far_ptr, "strokeWidth"); 
			break;