lsr_enc.c

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

	if (len) gf_bs_write_data(lsr->bs, str, len);
	GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[LASeR] %s\t\t%d\t\t%s\n", name, 8*len, str ? str : ""));
}
static void lsr_write_byte_align_string_list(GF_LASeRCodec *lsr, GF_List *l, const char *name, Bool is_iri)
{
	char text[4096];
	u32 i, count = gf_list_count(l);
	text[0] = 0;
	for (i=0; i<count; i++) {
		char *str;
		if (is_iri) {
			XMLRI *iri = (XMLRI *)gf_list_get(l, i);
			str = iri->string;
		} else {
			str = (char*)gf_list_get(l, i);
		}
		strcat(text, str);
		if (i+1<count) strcat(text, ";");
	}
	lsr_write_byte_align_string(lsr, text, name);
}

static void lsr_write_any_uri(GF_LASeRCodec *lsr, XMLRI *iri, const char *name)
{
	Bool is_iri = 0;

	if (iri->type==XMLRI_STRING) {
		is_iri = 1;
		if (iri->string[0]=='#') {
			iri->target = (SVG_Element*)gf_sg_find_node_by_name(lsr->sg, iri->string+1);
			if (iri->target) {
				is_iri = 0;
				iri->type = XMLRI_ELEMENTID;
			}
		}
	}

	GF_LSR_WRITE_INT(lsr, is_iri, 1, "hasUri");
	if (is_iri) {
		if (!iri->string || strnicmp(iri->string, "data:", 5)) {
			lsr_write_byte_align_string(lsr, iri->string, "uri");
			GF_LSR_WRITE_INT(lsr, 0, 1, "hasData");
		} else {
			u32 len;
			char *sep = strchr(iri->string, ',');
			sep[0] = 0;
			lsr_write_byte_align_string(lsr, iri->string, "uri");
			sep[0] = ',';
			len = strlen(sep+1);
			GF_LSR_WRITE_INT(lsr, 1, 1, "hasData");
			lsr_write_vluimsbf5(lsr, len, "len");
			gf_bs_write_data(lsr->bs, sep+1, len);
		}
	}
	GF_LSR_WRITE_INT(lsr, (iri->type==XMLRI_ELEMENTID) ? 1 : 0, 1, "hasID");
	if (iri->type==XMLRI_ELEMENTID) lsr_write_codec_IDREF(lsr, iri, "idref");

	GF_LSR_WRITE_INT(lsr, (iri->type==XMLRI_STREAMID) ? 1 : 0, 1, "hasID");
	if (iri->type==XMLRI_STREAMID) 
		lsr_write_codec_IDREF(lsr, iri, "ref");
}

static void lsr_write_paint(GF_LASeRCodec *lsr, SVG_Paint *paint, const char *name)
{
	if ((paint->type==SVG_PAINT_COLOR) && (paint->color.type==SVG_COLOR_RGBCOLOR)) {
		s32 idx;
		GF_LSR_WRITE_INT(lsr, 1, 1, "hasIndex");
		idx = lsr_get_col_index(lsr, &paint->color);
		if (idx<0) { 
			idx = 0; 
			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[LASeR] color not in colorTable\n")); 
		}
		GF_LSR_WRITE_INT(lsr, (u32) idx, lsr->colorIndexBits, name);
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "hasIndex");

		switch (paint->type) {
		case SVG_PAINT_INHERIT: 
			GF_LSR_WRITE_INT(lsr, 0, 2, "enum");
			GF_LSR_WRITE_INT(lsr, 0, 2, "choice"); 
			break;
		case SVG_PAINT_NONE: 
			GF_LSR_WRITE_INT(lsr, 0, 2, "enum");
			GF_LSR_WRITE_INT(lsr, 2, 2, "choice"); 
			break;
		case SVG_PAINT_COLOR: 
			if (paint->color.type == SVG_COLOR_CURRENTCOLOR) {
				GF_LSR_WRITE_INT(lsr, 0, 2, "enum");
				GF_LSR_WRITE_INT(lsr, 1, 2, "choice"); 
			} else {
				GF_LSR_WRITE_INT(lsr, 2, 2, "enum");
				lsr_write_byte_align_string(lsr, (char*)gf_svg_get_system_paint_server_name(paint->color.type), "systemsPaint");
			}
			break;
		case SVG_PAINT_URI:
			GF_LSR_WRITE_INT(lsr, 1, 2, "enum");
			lsr_write_any_uri(lsr, &paint->iri, "uri");
			break;

		default:
			GF_LSR_WRITE_INT(lsr, 3, 2, "enum");
			lsr_write_extension(lsr, "ERROR", 5, "colorExType0");
			break;
		}
	} 
}

static void lsr_write_private_element_container(GF_LASeRCodec *lsr)
{
	/*NO PRIVATE DATA ON ENCODING YET*/
	assert(0);
}

static void lsr_write_private_att_class(GF_LASeRCodec *lsr)
{
	/*NO PRIVATE DATA ON ENCODING YET*/
	assert(0);
}

static void lsr_write_private_attr_container(GF_LASeRCodec *lsr, u32 index, const char *name)
{
	assert(0);
}

static void lsr_write_any_attribute(GF_LASeRCodec *lsr, SVG_Element *node, Bool skippable)
{
	if (1) {
		if (skippable) GF_LSR_WRITE_INT(lsr, 0, 1, "has_attrs");
	} else {
		if (skippable) GF_LSR_WRITE_INT(lsr, 1, 1, "has_attrs");
/*
		do () {
			GF_LSR_WRITE_INT(lsr, 0, lsr->info->cfg.extensionIDBits, "reserved");
		    lsr_write_vluimsbf5(lsr, 0, "len");//len in BITS
			GF_LSR_WRITE_INT(lsr, 0, 0, "reserved_val");
		} while () 
*/
	}
}

static void lsr_write_private_attributes(GF_LASeRCodec *lsr, SVG_Element *elt)
{
	if (1) {
		GF_LSR_WRITE_INT(lsr, 0, 1, "has_private_attr");
	} else {
		GF_LSR_WRITE_INT(lsr, 1, 1, "has_private_attr");
		lsr_write_private_att_class(lsr);
	}
}
static void lsr_write_string_attribute(GF_LASeRCodec *lsr, char *class_attr, char *name)
{
	if (class_attr) {
		GF_LSR_WRITE_INT(lsr, 1, 1, name);
		lsr_write_byte_align_string(lsr, class_attr, name);
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, name);
	}
}
static void lsr_write_id(GF_LASeRCodec *lsr, GF_Node *n)
{
	u32 id = gf_node_get_id(n);
	if (id) {
		GF_LSR_WRITE_INT(lsr, 1, 1, "has_id");
	    lsr_write_vluimsbf5(lsr, id-1, "ID");
#if TODO_LASER_EXTENSIONS	
		if (0) {
			GF_LSR_WRITE_INT(lsr, 1, 1, "reserved");
		    lsr_write_vluimsbf5(lsr, reserved_len, "len");
			GF_LSR_WRITE_INT(lsr, 0, reserved_len, "reserved");
		} else 
#endif
			GF_LSR_WRITE_INT(lsr, 0, 1, "reserved");
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "has_id");
	}
}

static u32 lsr_translate_coords(GF_LASeRCodec *lsr, Fixed x, u32 nb_bits)
{
	s32 res, max;

	res = FIX2INT( gf_divfix(x, lsr->res_factor) );
	/*don't loose too much*/
	if (!res && x) {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[LASeR] resolution factor %g too small to allow coding of %g - adjusting to smallest integer!\n", lsr->res_factor, FIX2FLT(x) ));
		res = (x>0) ? 1 : -1;
	}
	max = (1<<(nb_bits-1)) - 1;
	if (res>=0) {
		if (res > max) {
			GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[LASeR] nb_bits %d not large enough to encode positive number %g!\n", nb_bits, FIX2FLT(x) ));
			res = max;
		}
		assert( ! (res & (1<<(nb_bits-1)) ));
		return (u32) res;
	}
	res += 1<<(nb_bits);
	if (res<=max){
		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[LASeR] nb_bits %d not large enough to encode negative number %g!\n", nb_bits, FIX2FLT(x) ));
		res = max+1;
	}
	assert( res & (1<<(nb_bits-1)) );
	return res;
}

static u32 lsr_translate_scale(GF_LASeRCodec *lsr, Fixed v)
{
	s32 res;
	/*always 8 bits for fractional part*/
	if (ABS(v) * 256 < 1) v = 0;
	v = v*256;
	if (v<0) {
		res = FIX2INT(v) + (1<<lsr->coord_bits);
		if (res<0) GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[LASeR] nb_bits %d not large enough to encode negative number %d!\n", lsr->coord_bits, res));
		return res;
	}
	res = FIX2INT(v);
	if (res & (1<<(lsr->coord_bits-1)) ) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[LASeR] nb_bits %d not large enough to encode positive number %d!\n", lsr->coord_bits, res));
	}
	return res;
}
static void lsr_write_matrix(GF_LASeRCodec *lsr, SVG_Transform *mx)
{
	u32 res;
	if (mx->is_ref) {
		GF_LSR_WRITE_INT(lsr, 1, 1, "isNotMatrix");
		GF_LSR_WRITE_INT(lsr, 1, 1, "isRef");
		GF_LSR_WRITE_INT(lsr, 1, 1, "hasXY");
		lsr_write_fixed_16_8(lsr, mx->mat.m[2], "valueX");
		lsr_write_fixed_16_8(lsr, mx->mat.m[5], "valueY");
	} else {
		GF_LSR_WRITE_INT(lsr, 0, 1, "isNotMatrix");
		lsr->coord_bits += lsr->scale_bits;

		if ((mx->mat.m[0]!=FIX_ONE) || (mx->mat.m[4]!=FIX_ONE)) {
			GF_LSR_WRITE_INT(lsr, 1, 1, "xx_yy_present");
			res = lsr_translate_scale(lsr, mx->mat.m[0]);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "xx");
			res = lsr_translate_scale(lsr, mx->mat.m[4]);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "yy");
		} else {
			GF_LSR_WRITE_INT(lsr, 0, 1, "xx_yy_present");
		}
		if (mx->mat.m[1] || mx->mat.m[3]) {
			GF_LSR_WRITE_INT(lsr, 1, 1, "xy_yx_present");
			res = lsr_translate_scale(lsr, mx->mat.m[1]);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "xy");
			res = lsr_translate_scale(lsr, mx->mat.m[3]);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "yx");
		} else {
			GF_LSR_WRITE_INT(lsr, 0, 1, "xy_yx_present");
		}
		lsr->coord_bits -= lsr->scale_bits;

		if (mx->mat.m[2] || mx->mat.m[5]) {
			GF_LSR_WRITE_INT(lsr, 1, 1, "xz_yz_present");
			res = lsr_translate_coords(lsr, mx->mat.m[2], lsr->coord_bits);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "xz");
			res = lsr_translate_coords(lsr, mx->mat.m[5], lsr->coord_bits);
			GF_LSR_WRITE_INT(lsr, res, lsr->coord_bits, "yz");
		} else {
			GF_LSR_WRITE_INT(lsr, 0, 1, "xz_yz_present");
		}
	}
}

static void lsr_write_fixed_clamp(GF_LASeRCodec *lsr, Fixed f, const char *name)
{
#ifdef GPAC_FIXED_POINT
	s32 val = f >> 8;
#else
	s32 val = (u32) (255 * f);
#endif
	if (val<0) val = 0;
	else if (val>255) val = 255;
	GF_LSR_WRITE_INT(lsr, (u32) val, 8, name);
}

static u32 dom_to_lsr_key(u32 dom_k)
{
	switch (dom_k) {
	case GF_KEY_STAR: return 0;
	case GF_KEY_0: return 1;
	case GF_KEY_1: return 2;
	case GF_KEY_2: return 3;
	case GF_KEY_3: return 4;
	case GF_KEY_4: return 5;
	case GF_KEY_5: return 6;
	case GF_KEY_6: return 7;
	case GF_KEY_7: return 8;
	case GF_KEY_8: return 9;
	case GF_KEY_9: return 10;
	case GF_KEY_DOWN: return 12;
	case GF_KEY_LEFT: return 14;
	case GF_KEY_RIGHT: return 16;
	case GF_KEY_UP: return 20;
	/*WHAT IS ANY_KEY (11) ??*/
	case GF_KEY_ENTER:
	case GF_KEY_EXECUTE:
		return 13;
	case GF_KEY_ESCAPE:
		return 15;
	case GF_KEY_NUMBER: 
		return 17;
	case GF_KEY_CELL_SOFT1: 
		return 18;
	case GF_KEY_CELL_SOFT2: 
		return 19;
	default:
		return 100;
	}
}
static void lsr_write_event_type(GF_LASeRCodec *lsr, u32 evtType, u32 evtParam)
{
	Bool force_string = 0;
	switch (evtType) {
	case GF_EVENT_KEYDOWN:
	case GF_EVENT_LONGKEYPRESS:
	case GF_EVENT_REPEAT_KEY:
	case GF_EVENT_SHORT_ACCESSKEY:
		if (dom_to_lsr_key(evtParam)==100) force_string = 2;
		break;
	case GF_EVENT_BEGIN:
	case GF_EVENT_END:
		force_string = 1;
		break;
	case GF_EVENT_REPEAT:
		force_string = 1;
		break;
	}

	if (force_string) {
		char szName[1024];
		GF_LSR_WRITE_INT(lsr, 0, 1, "choice");
		if (evtParam) {
			if (force_string==2) {
				sprintf(szName, "%s(%s)", gf_dom_event_get_name(evtType), gf_dom_get_key_name(evtParam) );
			} else {
				sprintf(szName, "%s(%d)", gf_dom_event_get_name(evtType), evtParam);
			}
		} else {
			sprintf(szName, "%s", gf_dom_event_get_name(evtType));
		}
		lsr_write_byte_align_string(lsr, szName, "evtString");
	} else {
		GF_LSR_WRITE_INT(lsr, 1, 1, "choice");
		switch (evtType) {
		case GF_EVENT_ABORT: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_abort, 6, "event"); break;
		case GF_EVENT_ACTIVATE: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_activate, 6, "event"); break;
		case GF_EVENT_ACTIVATED: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_activatedEvent, 6, "event"); break;
		case GF_EVENT_BEGIN:/*SPEC IS BROKEN, CANNOT ENCODE elt.begin !! */ 
		case GF_EVENT_BEGIN_EVENT: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_beginEvent, 6, "event"); break;
		case GF_EVENT_CLICK: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_click, 6, "event"); break;
		case GF_EVENT_DEACTIVATED: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_deactivatedEvent, 6, "event"); break;
		case GF_EVENT_END:/*SPEC IS BROKEN, CANNOT ENCODE elt.end !! */ 
		case GF_EVENT_END_EVENT: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_endEvent, 6, "event"); break;
		case GF_EVENT_ERROR: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_error, 6, "event"); break;
		case GF_EVENT_EXECUTION_TIME: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_executionTime, 6, "event"); break;
		case GF_EVENT_FOCUSIN: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_focusin, 6, "event"); break;
		case GF_EVENT_FOCUSOUT: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_focusout, 6, "event"); break;
		case GF_EVENT_KEYDOWN: 
			/*encode as accessKey() if param*/
			GF_LSR_WRITE_INT(lsr, evtParam ? LSR_EVT_accessKey : LSR_EVT_keydown, 6, "event"); 
			break;
		case GF_EVENT_KEYUP: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_keyup, 6, "event"); break;
		case GF_EVENT_LOAD: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_load, 6, "event"); break;
		case GF_EVENT_LONGKEYPRESS: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_longAccessKey, 6, "event"); break;
		case GF_EVENT_MOUSEDOWN: 
			GF_LSR_WRITE_INT(lsr, LSR_EVT_mousedown, 6, "event"); break;
		case GF_EVENT_MOUSEMOVE: