Fix bug in MediaTime comparison for negative values with different scale.
[WebKit-https.git] / Source / WTF / wtf / MediaTime.cpp
1 /*
2  * Copyright (C) 2012 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "MediaTime.h"
31
32 #include <algorithm>
33 #include <cstdlib>
34 #include <wtf/CheckedArithmetic.h>
35 #include <wtf/JSONValues.h>
36 #include <wtf/MathExtras.h>
37 #include <wtf/PrintStream.h>
38 #include <wtf/text/StringBuilder.h>
39
40 namespace WTF {
41
42 static uint32_t greatestCommonDivisor(uint32_t a, uint32_t b)
43 {
44     // Euclid's Algorithm
45     uint32_t temp = 0;
46     while (b) {
47         temp = b;
48         b = a % b;
49         a = temp;
50     }
51     return a;
52 }
53
54 static uint32_t leastCommonMultiple(uint32_t a, uint32_t b, uint32_t &result)
55 {
56     return safeMultiply(a, b / greatestCommonDivisor(a, b), result);
57 }
58
59 static int64_t signum(int64_t val)
60 {
61     return (0 < val) - (val < 0);
62 }
63
64 const uint32_t MediaTime::MaximumTimeScale = 0x7fffffffL;
65
66 MediaTime::MediaTime()
67     : m_timeValue(0)
68     , m_timeScale(DefaultTimeScale)
69     , m_timeFlags(Valid)
70 {
71 }
72
73 MediaTime::MediaTime(int64_t value, uint32_t scale, uint8_t flags)
74     : m_timeValue(value)
75     , m_timeScale(scale)
76     , m_timeFlags(flags)
77 {
78 }
79
80 MediaTime::~MediaTime()
81 {
82 }
83
84 MediaTime::MediaTime(const MediaTime& rhs)
85 {
86     *this = rhs;
87 }
88
89 MediaTime MediaTime::createWithFloat(float floatTime)
90 {
91     if (floatTime != floatTime)
92         return invalidTime();
93     if (std::isinf(floatTime))
94         return std::signbit(floatTime) ? negativeInfiniteTime() : positiveInfiniteTime();
95
96     MediaTime value(0, DefaultTimeScale, Valid | DoubleValue);
97     value.m_timeValueAsDouble = floatTime;
98     return value;
99 }
100
101 MediaTime MediaTime::createWithFloat(float floatTime, uint32_t timeScale)
102 {
103     if (floatTime != floatTime)
104         return invalidTime();
105     if (std::isinf(floatTime))
106         return std::signbit(floatTime) ? negativeInfiniteTime() : positiveInfiniteTime();
107     if (floatTime > std::numeric_limits<int64_t>::max())
108         return positiveInfiniteTime();
109     if (floatTime < std::numeric_limits<int64_t>::min())
110         return negativeInfiniteTime();
111
112     while (floatTime * timeScale > std::numeric_limits<int64_t>::max())
113         timeScale /= 2;
114     return MediaTime(static_cast<int64_t>(floatTime * timeScale), timeScale, Valid);
115 }
116
117 MediaTime MediaTime::createWithDouble(double doubleTime)
118 {
119     if (doubleTime != doubleTime)
120         return invalidTime();
121     if (std::isinf(doubleTime))
122         return std::signbit(doubleTime) ? negativeInfiniteTime() : positiveInfiniteTime();
123
124     MediaTime value(0, DefaultTimeScale, Valid | DoubleValue);
125     value.m_timeValueAsDouble = doubleTime;
126     return value;
127 }
128
129 MediaTime MediaTime::createWithDouble(double doubleTime, uint32_t timeScale)
130 {
131     if (doubleTime != doubleTime)
132         return invalidTime();
133     if (std::isinf(doubleTime))
134         return std::signbit(doubleTime) ? negativeInfiniteTime() : positiveInfiniteTime();
135     if (doubleTime > std::numeric_limits<int64_t>::max())
136         return positiveInfiniteTime();
137     if (doubleTime < std::numeric_limits<int64_t>::min())
138         return negativeInfiniteTime();
139
140     while (doubleTime * timeScale > std::numeric_limits<int64_t>::max())
141         timeScale /= 2;
142     return MediaTime(static_cast<int64_t>(std::round(doubleTime * timeScale)), timeScale, Valid);
143 }
144
145 float MediaTime::toFloat() const
146 {
147     if (isInvalid() || isIndefinite())
148         return std::numeric_limits<float>::quiet_NaN();
149     if (isPositiveInfinite())
150         return std::numeric_limits<float>::infinity();
151     if (isNegativeInfinite())
152         return -std::numeric_limits<float>::infinity();
153     if (hasDoubleValue())
154         return m_timeValueAsDouble;
155     return static_cast<float>(m_timeValue) / m_timeScale;
156 }
157
158 double MediaTime::toDouble() const
159 {
160     if (isInvalid() || isIndefinite())
161         return std::numeric_limits<double>::quiet_NaN();
162     if (isPositiveInfinite())
163         return std::numeric_limits<double>::infinity();
164     if (isNegativeInfinite())
165         return -std::numeric_limits<double>::infinity();
166     if (hasDoubleValue())
167         return m_timeValueAsDouble;
168     return static_cast<double>(m_timeValue) / m_timeScale;
169 }
170
171 MediaTime& MediaTime::operator=(const MediaTime& rhs)
172 {
173     m_timeValue = rhs.m_timeValue;
174     m_timeScale = rhs.m_timeScale;
175     m_timeFlags = rhs.m_timeFlags;
176     return *this;
177 }
178
179 MediaTime MediaTime::operator+(const MediaTime& rhs) const
180 {
181     if (rhs.isInvalid() || isInvalid())
182         return invalidTime();
183
184     if (rhs.isIndefinite() || isIndefinite())
185         return indefiniteTime();
186
187     if (isPositiveInfinite() && rhs.isNegativeInfinite())
188         return invalidTime();
189
190     if (isNegativeInfinite() && rhs.isPositiveInfinite())
191         return invalidTime();
192
193     if (isPositiveInfinite() || rhs.isPositiveInfinite())
194         return positiveInfiniteTime();
195
196     if (isNegativeInfinite() || rhs.isNegativeInfinite())
197         return negativeInfiniteTime();
198
199     if (hasDoubleValue() && rhs.hasDoubleValue())
200         return MediaTime::createWithDouble(m_timeValueAsDouble + rhs.m_timeValueAsDouble);
201
202     if (hasDoubleValue() || rhs.hasDoubleValue())
203         return MediaTime::createWithDouble(toDouble() + rhs.toDouble());
204
205     MediaTime a = *this;
206     MediaTime b = rhs;
207
208     uint32_t commonTimeScale;
209     if (!leastCommonMultiple(a.m_timeScale, b.m_timeScale, commonTimeScale) || commonTimeScale > MaximumTimeScale)
210         commonTimeScale = MaximumTimeScale;
211     a.setTimeScale(commonTimeScale);
212     b.setTimeScale(commonTimeScale);
213     while (!safeAdd(a.m_timeValue, b.m_timeValue, a.m_timeValue)) {
214         if (commonTimeScale == 1)
215             return a.m_timeValue > 0 ? positiveInfiniteTime() : negativeInfiniteTime();
216         commonTimeScale /= 2;
217         a.setTimeScale(commonTimeScale);
218         b.setTimeScale(commonTimeScale);
219     }
220     return a;
221 }
222
223 MediaTime MediaTime::operator-(const MediaTime& rhs) const
224 {
225     if (rhs.isInvalid() || isInvalid())
226         return invalidTime();
227
228     if (rhs.isIndefinite() || isIndefinite())
229         return indefiniteTime();
230
231     if (isPositiveInfinite() && rhs.isPositiveInfinite())
232         return invalidTime();
233
234     if (isNegativeInfinite() && rhs.isNegativeInfinite())
235         return invalidTime();
236
237     if (isPositiveInfinite() || rhs.isNegativeInfinite())
238         return positiveInfiniteTime();
239
240     if (isNegativeInfinite() || rhs.isPositiveInfinite())
241         return negativeInfiniteTime();
242
243     if (hasDoubleValue() && rhs.hasDoubleValue())
244         return MediaTime::createWithDouble(m_timeValueAsDouble - rhs.m_timeValueAsDouble);
245
246     if (hasDoubleValue() || rhs.hasDoubleValue())
247         return MediaTime::createWithDouble(toDouble() - rhs.toDouble());
248
249     MediaTime a = *this;
250     MediaTime b = rhs;
251
252     uint32_t commonTimeScale;
253     if (!leastCommonMultiple(this->m_timeScale, rhs.m_timeScale, commonTimeScale) || commonTimeScale > MaximumTimeScale)
254         commonTimeScale = MaximumTimeScale;
255     a.setTimeScale(commonTimeScale);
256     b.setTimeScale(commonTimeScale);
257     while (!safeSub(a.m_timeValue, b.m_timeValue, a.m_timeValue)) {
258         if (commonTimeScale == 1)
259             return a.m_timeValue > 0 ? positiveInfiniteTime() : negativeInfiniteTime();
260         commonTimeScale /= 2;
261         a.setTimeScale(commonTimeScale);
262         b.setTimeScale(commonTimeScale);
263     }
264     return a;
265 }
266
267 MediaTime MediaTime::operator-() const
268 {
269     if (isInvalid())
270         return invalidTime();
271
272     if (isIndefinite())
273         return indefiniteTime();
274
275     if (isPositiveInfinite())
276         return negativeInfiniteTime();
277
278     if (isNegativeInfinite())
279         return positiveInfiniteTime();
280
281     MediaTime negativeTime = *this;
282     if (negativeTime.hasDoubleValue())
283         negativeTime.m_timeValueAsDouble = -negativeTime.m_timeValueAsDouble;
284     else
285         negativeTime.m_timeValue = -negativeTime.m_timeValue;
286     return negativeTime;
287 }
288
289 MediaTime MediaTime::operator*(int32_t rhs) const
290 {
291     if (isInvalid())
292         return invalidTime();
293
294     if (isIndefinite())
295         return indefiniteTime();
296
297     if (!rhs)
298         return zeroTime();
299
300     if (isPositiveInfinite()) {
301         if (rhs > 0)
302             return positiveInfiniteTime();
303         return negativeInfiniteTime();
304     }
305
306     if (isNegativeInfinite()) {
307         if (rhs > 0)
308             return negativeInfiniteTime();
309         return positiveInfiniteTime();
310     }
311
312     MediaTime a = *this;
313
314     if (a.hasDoubleValue()) {
315         a.m_timeValueAsDouble *= rhs;
316         return a;
317     }
318
319     while (!safeMultiply(a.m_timeValue, rhs, a.m_timeValue)) {
320         if (a.m_timeScale == 1)
321             return signum(a.m_timeValue) == signum(rhs) ? positiveInfiniteTime() : negativeInfiniteTime();
322         a.setTimeScale(a.m_timeScale / 2);
323     }
324
325     return a;
326 }
327
328 bool MediaTime::operator!() const
329 {
330     return (m_timeFlags == Valid && !m_timeValue)
331         || (m_timeFlags == (Valid | DoubleValue) && !m_timeValueAsDouble);
332 }
333
334 MediaTime::operator bool() const
335 {
336     return !(m_timeFlags == Valid && !m_timeValue)
337         && !(m_timeFlags == (Valid | DoubleValue) && !m_timeValueAsDouble);
338 }
339
340 MediaTime::ComparisonFlags MediaTime::compare(const MediaTime& rhs) const
341 {
342     auto andFlags = m_timeFlags & rhs.m_timeFlags;
343     if (andFlags & (PositiveInfinite | NegativeInfinite | Indefinite))
344         return EqualTo;
345
346     auto orFlags = m_timeFlags | rhs.m_timeFlags;
347     if (!(orFlags & Valid))
348         return EqualTo;
349
350     if (!(andFlags & Valid))
351         return isInvalid() ? GreaterThan : LessThan;
352
353     if (orFlags & NegativeInfinite)
354         return isNegativeInfinite() ? LessThan : GreaterThan;
355
356     if (orFlags & PositiveInfinite)
357         return isPositiveInfinite() ? GreaterThan : LessThan;
358
359     if (orFlags & Indefinite)
360         return isIndefinite() ? GreaterThan : LessThan;
361
362     if (andFlags & DoubleValue) {
363         if (m_timeValueAsDouble == rhs.m_timeValueAsDouble)
364             return EqualTo;
365
366         return m_timeValueAsDouble < rhs.m_timeValueAsDouble ? LessThan : GreaterThan;
367     }
368
369     if (orFlags & DoubleValue) {
370         double a = toDouble();
371         double b = rhs.toDouble();
372         if (a > b)
373             return GreaterThan;
374         if (a < b)
375             return LessThan;
376         return EqualTo;
377     }
378
379     if ((m_timeValue < 0) != (rhs.m_timeValue < 0))
380         return m_timeValue < 0 ? LessThan : GreaterThan;
381
382     if (!m_timeValue && !rhs.m_timeValue)
383         return EqualTo;
384
385     if (m_timeScale == rhs.m_timeScale) {
386         if (m_timeValue == rhs.m_timeValue)
387             return EqualTo;
388         return m_timeValue < rhs.m_timeValue ? LessThan : GreaterThan;
389     }
390
391     if (m_timeValue == rhs.m_timeValue)
392         return m_timeScale < rhs.m_timeScale ? GreaterThan : LessThan;
393
394     if (m_timeValue >= 0) {
395         if (m_timeValue < rhs.m_timeValue && m_timeScale > rhs.m_timeScale)
396             return LessThan;
397
398         if (m_timeValue > rhs.m_timeValue && m_timeScale < rhs.m_timeScale)
399             return GreaterThan;
400     } else {
401         if (m_timeValue < rhs.m_timeValue && m_timeScale < rhs.m_timeScale)
402             return LessThan;
403
404         if (m_timeValue > rhs.m_timeValue && m_timeScale > rhs.m_timeScale)
405             return GreaterThan;
406     }
407
408     int64_t lhsFactor;
409     int64_t rhsFactor;
410     if (safeMultiply(m_timeValue, static_cast<int64_t>(rhs.m_timeScale), lhsFactor)
411         && safeMultiply(rhs.m_timeValue, static_cast<int64_t>(m_timeScale), rhsFactor)) {
412         if (lhsFactor == rhsFactor)
413             return EqualTo;
414         return lhsFactor < rhsFactor ? LessThan : GreaterThan;
415     }
416
417     int64_t rhsWhole = rhs.m_timeValue / rhs.m_timeScale;
418     int64_t lhsWhole = m_timeValue / m_timeScale;
419     if (lhsWhole > rhsWhole)
420         return GreaterThan;
421     if (lhsWhole < rhsWhole)
422         return LessThan;
423
424     int64_t rhsRemain = rhs.m_timeValue % rhs.m_timeScale;
425     int64_t lhsRemain = m_timeValue % m_timeScale;
426     lhsFactor = lhsRemain * rhs.m_timeScale;
427     rhsFactor = rhsRemain * m_timeScale;
428
429     if (lhsFactor == rhsFactor)
430         return EqualTo;
431     return lhsFactor > rhsFactor ? GreaterThan : LessThan;
432 }
433
434 bool MediaTime::isBetween(const MediaTime& a, const MediaTime& b) const
435 {
436     if (a > b)
437         return *this > b && *this < a;
438     return *this > a && *this < b;
439 }
440
441 const MediaTime& MediaTime::zeroTime()
442 {
443     static const MediaTime* time = new MediaTime(0, 1, Valid);
444     return *time;
445 }
446
447 const MediaTime& MediaTime::invalidTime()
448 {
449     static const MediaTime* time = new MediaTime(-1, 1, 0);
450     return *time;
451 }
452
453 const MediaTime& MediaTime::positiveInfiniteTime()
454 {
455     static const MediaTime* time = new MediaTime(0, 1, PositiveInfinite | Valid);
456     return *time;
457 }
458
459 const MediaTime& MediaTime::negativeInfiniteTime()
460 {
461     static const MediaTime* time = new MediaTime(-1, 1, NegativeInfinite | Valid);
462     return *time;
463 }
464
465 const MediaTime& MediaTime::indefiniteTime()
466 {
467     static const MediaTime* time = new MediaTime(0, 1, Indefinite | Valid);
468     return *time;
469 }
470
471 MediaTime MediaTime::toTimeScale(uint32_t timeScale, RoundingFlags flags) const
472 {
473     MediaTime result = *this;
474     result.setTimeScale(timeScale, flags);
475     return result;
476 }
477
478 void MediaTime::setTimeScale(uint32_t timeScale, RoundingFlags flags)
479 {
480     if (hasDoubleValue()) {
481         *this = MediaTime::createWithDouble(m_timeValueAsDouble, timeScale);
482         return;
483     }
484
485     if (timeScale == m_timeScale)
486         return;
487
488     timeScale = std::min(MaximumTimeScale, timeScale);
489
490 #if HAVE(INT128_T)
491     __int128_t newValue = static_cast<__int128_t>(m_timeValue) * timeScale;
492     int64_t remainder = newValue % m_timeScale;
493     newValue = newValue / m_timeScale;
494
495     if (newValue < std::numeric_limits<int64_t>::min()) {
496         *this = negativeInfiniteTime();
497         return;
498     }
499
500     if (newValue > std::numeric_limits<int64_t>::max()) {
501         *this = positiveInfiniteTime();
502         return;
503     }
504 #else
505     int64_t newValue = m_timeValue / m_timeScale;
506     int64_t partialRemainder = (m_timeValue % m_timeScale) * timeScale;
507     int64_t remainder = partialRemainder % m_timeScale;
508
509     if (!safeMultiply<int64_t>(newValue, static_cast<int64_t>(timeScale), newValue)
510         || !safeAdd(newValue, partialRemainder / m_timeScale, newValue)) {
511         *this = newValue < 0 ? negativeInfiniteTime() : positiveInfiniteTime();
512         return;
513     }
514 #endif
515
516     m_timeValue = newValue;
517     std::swap(m_timeScale, timeScale);
518
519     if (!remainder)
520         return;
521
522     m_timeFlags |= HasBeenRounded;
523     switch (flags) {
524     case RoundingFlags::HalfAwayFromZero:
525         if (static_cast<int64_t>(llabs(remainder)) * 2 >= static_cast<int64_t>(timeScale)) {
526             // round up (away from zero)
527             if (remainder < 0)
528                 m_timeValue--;
529             else
530                 m_timeValue++;
531         }
532         break;
533
534     case RoundingFlags::TowardZero:
535         break;
536
537     case RoundingFlags::AwayFromZero:
538         if (remainder < 0)
539             m_timeValue--;
540         else
541             m_timeValue++;
542         break;
543
544     case RoundingFlags::TowardPositiveInfinity:
545         if (remainder > 0)
546             m_timeValue++;
547         break;
548         
549     case RoundingFlags::TowardNegativeInfinity:
550         if (remainder < 0)
551             m_timeValue--;
552         break;
553     }
554 }
555
556 void MediaTime::dump(PrintStream& out) const
557 {
558     out.print("{");
559     if (!hasDoubleValue())
560         out.print(m_timeValue, "/", m_timeScale, " = ");
561     out.print(toDouble(), "}");
562 }
563
564 String MediaTime::toString() const
565 {
566     StringBuilder builder;
567
568     builder.append('{');
569     if (!hasDoubleValue()) {
570         builder.appendNumber(m_timeValue);
571         builder.append('/');
572         builder.appendNumber(m_timeScale);
573         builder.appendLiteral(" = ");
574     }
575     builder.appendNumber(toDouble());
576     builder.append('}');
577     return builder.toString();
578 }
579
580 String MediaTime::toJSONString() const
581 {
582     auto object = JSON::Object::create();
583
584     if (hasDoubleValue())
585         object->setDouble(ASCIILiteral("value"), toDouble());
586     else {
587         if (isInvalid() || isIndefinite())
588             object->setString(ASCIILiteral("value"), ASCIILiteral("NaN"));
589         else if (isPositiveInfinite())
590             object->setString(ASCIILiteral("value"), ASCIILiteral("POSITIVE_INFINITY"));
591         else if (isNegativeInfinite())
592             object->setString(ASCIILiteral("value"), ASCIILiteral("NEGATIVE_INFINITY"));
593         else
594             object->setDouble(ASCIILiteral("value"), toDouble());
595
596         object->setInteger(ASCIILiteral("numerator"), static_cast<int>(m_timeValue));
597         object->setInteger(ASCIILiteral("denominator"), m_timeScale);
598         object->setInteger(ASCIILiteral("flags"), m_timeFlags);
599     }
600
601     return object->toJSONString();
602 }
603
604 MediaTime abs(const MediaTime& rhs)
605 {
606     if (rhs.isInvalid())
607         return MediaTime::invalidTime();
608     if (rhs.isNegativeInfinite() || rhs.isPositiveInfinite())
609         return MediaTime::positiveInfiniteTime();
610     if (rhs.hasDoubleValue())
611         return MediaTime::createWithDouble(fabs(rhs.m_timeValueAsDouble));
612
613     MediaTime val = rhs;
614     val.m_timeValue = std::abs(rhs.m_timeValue);
615     return val;
616 }
617
618 }
619