parselets.cpp

彩信浏览器

		delimiter_p space(" \t\r\n");
		star_p<delimiter_p> opt_space_inst = make_star(space);

		d = opt_space_inst.parse(test_it, end);
		rd += (d == -1)?0:d;
		
		delimiter_p sign_inst("+-");
		d = sign_inst.parse(test_it, end);
		int sign = (d == -1)?1:( (sign_inst.m_result == '+')?1:-1 );
		rd += (d == -1)?0:d;
	
		d = opt_space_inst.parse(test_it, end);
		rd += (d == -1)?0:d;
		
		clock_value_p c;
		d = c.parse(test_it, end);
		if(d == -1) return -1;
		rd += d;
		it = test_it;
		m_result = sign*c.m_result;
		return rd;
}

//////////////////////
// coord_p

std::ptrdiff_t 
lib::coord_p::parse(const_iterator& it, const const_iterator& end) {
	const_iterator tit = it;
	std::ptrdiff_t d;
	std::ptrdiff_t sd = 0;
	
	// we need this if we want to allow optional space between value and units
	delimiter_p space(" \t\r\n");
	star_p<delimiter_p> opt_space_inst = make_star(space);
		
	// parse value
	number_p p1;
	d = p1.parse(tit, end);
	if(d == -1) return -1;
	m_result.value = p1.m_result;
	sd += d;
	
	// allow optional space between value and units
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// parse optional units	
	length_unit_p p2;
	d = p2.parse(tit, end);
	if(d == -1) return (m_result.unit = length_unit_p::px, it = tit, sd);
	sd += d;
	return (m_result.unit = p2.m_result, it = tit, sd);
}

//////////////////////
// region_dim_p

std::ptrdiff_t 
lib::region_dim_p::parse(const_iterator& it, const const_iterator& end) {
	const_iterator tit = it;
	std::ptrdiff_t d;
	std::ptrdiff_t sd = 0;
	
	delimiter_p space(" \t\r\n");
	star_p<delimiter_p> opt_space_inst = make_star(space);
		
	// S?
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// int | double
	number_p val_p;
	d = val_p.parse(tit, end);
	if(d == -1) return -1;
	sd += d;
	m_result.dbl_val = val_p.m_result;
	
	// S?
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// (px)? | %
	literal_cstr_p px_cstr_p("px");
	literal_cstr_p pc_cstr_p("%");
	or_pair_p<literal_cstr_p, literal_cstr_p> type_p(px_cstr_p, pc_cstr_p);
	d = type_p.parse(tit, end);
	if(d == -1 || type_p.matched_first()) {
		// interpret as int
		m_result.relative = false;
		m_result.int_val = int(floor(0.5+m_result.dbl_val));
	} else /*if(type_p.matched_second())*/ {
		m_result.relative = true;
		m_result.dbl_val *= 0.01;
	}
	sd += (d == -1)?0:d;
	return (it = tit, sd);
}

//////////////////////
// point_p

// S? (? d+ S? , S? d+  S? )?
std::ptrdiff_t 
lib::point_p::parse(const_iterator& it, const const_iterator& end) {
	const_iterator tit = it;
	std::ptrdiff_t d;
	std::ptrdiff_t sd = 0;
	
	delimiter_p space(" \t\r\n");
	star_p<delimiter_p> opt_space_inst = make_star(space);
	
	// S?
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// (?
	d = literal_p<'('>().parse(tit, end);
	sd += (d == -1)?0:d;
	bool expectRP = (d == -1)?false:true;
	
	// x value
	int_p ip;
	d = ip.parse(tit, end);
	if(d == -1) return -1;
	m_result.x = ip.m_result;
	sd += d;
	
	// S?
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// value sep opt
	d = literal_p<','>().parse(tit, end);
	sd += (d == -1)?0:d;

	// S?
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	
	// y value
	d = ip.parse(tit, end);
	if(d == -1) return -1;
	m_result.y = ip.m_result;
	sd += d;
	
	if(expectRP) {
		// S?
		d = opt_space_inst.parse(tit, end);
		sd += (d == -1)?0:d;
		
		// )
		d = literal_p<')'>().parse(tit, end);
		if(d == -1) return -1;
		sd += d;
	}
	return (it = tit, sd);
}

//This parser parses smpte smpte-30-drop and smpte-25 time formats
std::ptrdiff_t 
lib::smpte_p::parse(const_iterator& it, const const_iterator& end)
{
	const_iterator tit = it;
	std::ptrdiff_t d;
	std::ptrdiff_t sd = 0;
	
	int result;
	
	m_drop = false;
	m_frame_rate = 30;
	
	delimiter_p space(" \t\r\n");
	
	star_p<delimiter_p> opt_space_inst = make_star(space);
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	if (d == -1) {
		logger::get_logger()->debug("Failed to parse optional space ");
	}
	
	d = literal_cstr_p("smpte").parse(tit,end);
	sd += (d == -1)?0:d;
	if (d == -1) 
		return -1;
	
	d = literal_p<'-'>().parse(tit,end);
	sd += (d == -1)?0:d;
	int_p ip;
	if (d != -1) {
		d = ip.parse(tit,end);
		int r = ip.m_result;
		if (r == 25) 
		{	
			AM_DBG logger::get_logger()->debug("smpte-25");
			m_frame_rate = 25;
			m_drop = false;
		} else {
			AM_DBG logger::get_logger()->debug("smpte-30");
			m_frame_rate = 30;
			m_drop = false;
		}
				
	} else {
		m_frame_rate = 30;
		m_drop = false;
	}
	
	d = literal_cstr_p("-drop").parse(tit,end);
	if (d == -1) {
		m_drop = false;
	} else {
		AM_DBG logger::get_logger()->debug("drop");
		m_drop = true;
	}
	
	
	d = literal_p<'='>().parse(tit,end);
	sd += (d == -1)?0:d;
	if (d == -1) {
		AM_DBG logger::get_logger()->debug("smpte parser failed to parse literal = ");
	}
	
	

	//parse the actual smpte values
	for(int i=0; i<3; i++) {
		d = ip.parse(tit,end);
		if (d == -1) { 
			AM_DBG logger::get_logger()->debug("smpte parser failed to parse smtpe (i=%d)", i);
			return -1;
		}
		
		m_result[i] = ip.m_result;
		if ( (i > 0) && ( (m_result[i] < 0) || (m_result[i] > 59)) ) {
			logger::get_logger()->trace("Failed to parse smpte minutes/seconds. Value out of range [0,59]");
			m_result[i] = 0;
		}

		sd += d;
		
		d = literal_p<':'>().parse(tit,end);
		sd += (d == -1)?0:d;
	}
	
	
	
	d = ip.parse(tit,end);
	if (d != -1) { 
		result = ip.m_result;
		if ( (result >= 0) && (result < m_frame_rate)) // range [0, framerate-1]
			m_result[3] = ip.m_result;
		else {
			logger::get_logger()->trace("Failed to parse smpte frames. Value out of range [0,%d]",m_frame_rate-1);
			m_result[3] = 0;
		}
			
	} else {
		m_result[3] = 0;
	}
	
	sd += (d == -1)?0:d;
			
	d = literal_p<'.'>().parse(tit,end);
	sd += (d == -1)?0:d;
	
	d = ip.parse(tit,end);
	if (d != -1) { 
		result = ip.m_result;
		if ( (result >= 0) && (result < 2) ) // range [0,1]
			m_result[4] = ip.m_result;
		else {
			logger::get_logger()->trace("Failed to parse smpte sub-frames. Value out of range [0,1]");
			m_result[4] = 0;
		}
		m_result[4] = ip.m_result;
	} else {
		m_result[4] = 0;
	}

	sd += (d == -1)?0:d;
	return (it=tit, sd);
}

long int 
lib::smpte_p::get_time()
{
	long int time;
	double frame_duration;
	
	if ((m_frame_rate == 30)) 
		frame_duration = 1.001/30;
	else 
		frame_duration = 1.0/25;
	
	time = (m_result[0]*60*60*1000) + (m_result[1]*60*1000) + (m_result[2] *1000) + (long int) ::floor( ((m_result[3] * frame_duration  + m_result[4] * frame_duration/2) + 0.5 ) * 1000);
	
	return time;
}

//This parser parses npt time format
std::ptrdiff_t 
lib::npt_p::parse(const_iterator& it, const const_iterator& end)
{
	const_iterator tit = it;
	std::ptrdiff_t d;
	std::ptrdiff_t sd = 0;
	
	m_result = -1;
	
	
	delimiter_p space(" \t\r\n");
	
	star_p<delimiter_p> opt_space_inst = make_star(space);
	d = opt_space_inst.parse(tit, end);
	sd += (d == -1)?0:d;
	AM_DBG {
		if (d == -1) {
			logger::get_logger()->debug("ntp parser failed to parse optional space");
		} else {
			logger::get_logger()->debug("ntp parser succeded to parse optional space");
		}
	}
	
	d = literal_cstr_p("npt").parse(tit,end);
	sd += (d == -1)?0:d;
	
	d = literal_p<'='>().parse(tit,end);
	sd += (d == -1)?0:d;
	AM_DBG { 
		if (d == -1) {
			logger::get_logger()->debug("ntp parser failed to parse literal = ");
		} else {
			logger::get_logger()->debug("ntp parser succeded to parse literal = ");
		}
	}
	
		
	lib::clock_value_p parser;
		
	d = parser.parse(tit,end);
	sd+= (d == -1)?0:d;
	if (d == -1) {
		AM_DBG logger::get_logger()->debug("ntp parser failed to parse time");
		return -1;
	} else {
		m_result = parser.get_value();
		AM_DBG logger::get_logger()->debug("ntp parser succeded to parse time %ld",m_result);

	}
	
	return (it=tit, sd);
}


long int 
lib::npt_p::get_time()
{
	return m_result;
}

std::ptrdiff_t 
lib::mediaclipping_p::parse(const_iterator& it, const const_iterator& end)
{
	const_iterator tit = it;
	std::ptrdiff_t d;
	
	lib::smpte_p smpte_parser;
	lib::npt_p npt_parser;
	
	m_result = -1;

	d = npt_parser.parse(tit, end);
	
	if (d != -1) {
		m_result = npt_parser.get_time();
		return (it = tit, d);
	}

	d = smpte_parser.parse(tit,end);
	if (d != -1) {
		m_result = smpte_parser.get_time();
		return (it = tit, d);
	}
	
	return -1;
	
}

long int 
lib::mediaclipping_p::get_time()
{
	return m_result;
}