Variant f_range(CVarRef low, CVarRef high, CVarRef step /* = 1 */) {
bool is_step_double = false;
double dstep = 1.0;
if (step.isDouble()) {
dstep = step.toDouble();
is_step_double = true;
} else if (step.isString()) {
int64_t sn;
double sd;
DataType stype = step.toString()->isNumericWithVal(sn, sd, 0);
if (stype == KindOfDouble) {
is_step_double = true;
dstep = sd;
} else if (stype == KindOfInt64) {
dstep = (double)sn;
} else {
dstep = step.toDouble();
}
} else {
dstep = step.toDouble();
}
/* We only want positive step values. */
if (dstep < 0.0) dstep *= -1;
if (low.isString() && high.isString()) {
String slow = low.toString();
String shigh = high.toString();
if (slow.size() >= 1 && shigh.size() >=1) {
int64_t n1, n2;
double d1, d2;
DataType type1 = slow->isNumericWithVal(n1, d1, 0);
DataType type2 = shigh->isNumericWithVal(n2, d2, 0);
if (type1 == KindOfDouble || type2 == KindOfDouble || is_step_double) {
if (type1 != KindOfDouble) d1 = slow.toDouble();
if (type2 != KindOfDouble) d2 = shigh.toDouble();
return ArrayUtil::Range(d1, d2, dstep);
}
int64_t lstep = (int64_t) dstep;
if (type1 == KindOfInt64 || type2 == KindOfInt64) {
if (type1 != KindOfInt64) n1 = slow.toInt64();
if (type2 != KindOfInt64) n2 = shigh.toInt64();
return ArrayUtil::Range((double)n1, (double)n2, lstep);
}
return ArrayUtil::Range((unsigned char)slow.charAt(0),
(unsigned char)shigh.charAt(0), lstep);
}
}
if (low.is(KindOfDouble) || high.is(KindOfDouble) || is_step_double) {
return ArrayUtil::Range(low.toDouble(), high.toDouble(), dstep);
}
int64_t lstep = (int64_t) dstep;
return ArrayUtil::Range(low.toDouble(), high.toDouble(), lstep);
}
double parseToDoubleForNumberType(const String& string, double fallbackValue)
{
// See HTML5 2.5.4.3 `Real numbers.'
// String::toDouble() accepts leading + and whitespace characters, which are not valid here.
UChar firstCharacter = string[0];
if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
return fallbackValue;
bool valid = false;
double value = string.toDouble(&valid);
if (!valid)
return fallbackValue;
// NaN and infinity are considered valid by String::toDouble, but not valid here.
if (!std::isfinite(value))
return fallbackValue;
// Numbers are considered finite IEEE 754 single-precision floating point values.
// See HTML5 2.5.4.3 `Real numbers.'
if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max())
return fallbackValue;
// The following expression converts -0 to +0.
return value ? value : 0;
}
TextureMapperFPSCounter::TextureMapperFPSCounter()
: m_isShowingFPS(false)
, m_fpsInterval(0)
, m_fpsTimestamp(0)
, m_lastFPS(0)
, m_frameCount(0)
{
String showFPSEnvironment = getenv("WEBKIT_SHOW_FPS");
bool ok = false;
m_fpsInterval = showFPSEnvironment.toDouble(&ok);
if (ok && m_fpsInterval) {
m_isShowingFPS = true;
m_fpsTimestamp = WTF::currentTime();
}
}
SMILTime SVGSMILElement::parseOffsetValue(const String& data) {
bool ok;
double result = 0;
String parse = data.stripWhiteSpace();
if (parse.endsWith('h'))
result = parse.left(parse.length() - 1).toDouble(&ok) * 60 * 60;
else if (parse.endsWith("min"))
result = parse.left(parse.length() - 3).toDouble(&ok) * 60;
else if (parse.endsWith("ms"))
result = parse.left(parse.length() - 2).toDouble(&ok) / 1000;
else if (parse.endsWith('s'))
result = parse.left(parse.length() - 1).toDouble(&ok);
else
result = parse.toDouble(&ok);
if (!ok || !SMILTime(result).isFinite())
return SMILTime::unresolved();
return result;
}
bool MediaFragmentURIParser::parseNPTTime(const LChar* timeString, unsigned length, unsigned& offset, MediaTime& time)
{
enum Mode { minutes, hours };
Mode mode = minutes;
if (offset >= length || !isASCIIDigit(timeString[offset]))
return false;
// http://www.w3.org/2008/WebVideo/Fragments/WD-media-fragments-spec/#npttimedef
// Normal Play Time can either be specified as seconds, with an optional
// fractional part to indicate miliseconds, or as colon-separated hours,
// minutes and seconds (again with an optional fraction). Minutes and
// seconds must be specified as exactly two digits, hours and fractional
// seconds can be any number of digits. The hours, minutes and seconds
// specification for NPT is a convenience only, it does not signal frame
// accuracy. The specification of the "npt:" identifier is optional since
// NPT is the default time scheme. This specification builds on the RTSP
// specification of NPT RFC 2326.
//
// ; defined in RFC 2326
// npt-sec = 1*DIGIT [ "." *DIGIT ] ; definitions taken
// npt-hhmmss = npt-hh ":" npt-mm ":" npt-ss [ "." *DIGIT] ; from RFC 2326
// npt-mmss = npt-mm ":" npt-ss [ "." *DIGIT]
// npt-hh = 1*DIGIT ; any positive number
// npt-mm = 2DIGIT ; 0-59
// npt-ss = 2DIGIT ; 0-59
String digits1 = collectDigits(timeString, length, offset);
int value1 = digits1.toInt();
if (offset >= length || timeString[offset] == ',') {
time = MediaTime::createWithDouble(value1);
return true;
}
MediaTime fraction;
if (timeString[offset] == '.') {
if (offset == length)
return true;
String digits = collectFraction(timeString, length, offset);
fraction = MediaTime::createWithDouble(digits.toDouble());
time = MediaTime::createWithDouble(value1) + fraction;
return true;
}
if (digits1.length() < 2)
return false;
if (digits1.length() > 2)
mode = hours;
// Collect the next sequence of 0-9 after ':'
if (offset >= length || timeString[offset++] != ':')
return false;
if (offset >= length || !isASCIIDigit(timeString[(offset)]))
return false;
String digits2 = collectDigits(timeString, length, offset);
int value2 = digits2.toInt();
if (digits2.length() != 2)
return false;
// Detect whether this timestamp includes hours.
int value3;
if (mode == hours || (offset < length && timeString[offset] == ':')) {
if (offset >= length || timeString[offset++] != ':')
return false;
if (offset >= length || !isASCIIDigit(timeString[offset]))
return false;
String digits3 = collectDigits(timeString, length, offset);
if (digits3.length() != 2)
return false;
value3 = digits3.toInt();
} else {
value3 = value2;
value2 = value1;
value1 = 0;
}
if (offset < length && timeString[offset] == '.')
fraction = MediaTime::createWithDouble(collectFraction(timeString, length, offset).toDouble());
time = MediaTime::createWithDouble((value1 * secondsPerHour) + (value2 * secondsPerMinute) + value3) + fraction;
return true;
}