Ichthyostega
806db414dd
* Lumiera source code always was copyrighted by individual contributors * there is no entity "Lumiera.org" which holds any copyrights * Lumiera source code is provided under the GPL Version 2+ == Explanations == Lumiera as a whole is distributed under Copyleft, GNU General Public License Version 2 or above. For this to become legally effective, the ''File COPYING in the root directory is sufficient.'' The licensing header in each file is not strictly necessary, yet considered good practice; attaching a licence notice increases the likeliness that this information is retained in case someone extracts individual code files. However, it is not by the presence of some text, that legally binding licensing terms become effective; rather the fact matters that a given piece of code was provably copyrighted and published under a license. Even reformatting the code, renaming some variables or deleting parts of the code will not alter this legal situation, but rather creates a derivative work, which is likewise covered by the GPL! The most relevant information in the file header is the notice regarding the time of the first individual copyright claim. By virtue of this initial copyright, the first author is entitled to choose the terms of licensing. All further modifications are permitted and covered by the License. The specific wording or format of the copyright header is not legally relevant, as long as the intention to publish under the GPL remains clear. The extended wording was based on a recommendation by the FSF. It can be shortened, because the full terms of the license are provided alongside the distribution, in the file COPYING.
253 lines
10 KiB
C++
253 lines
10 KiB
C++
/*
|
||
QuantiserBasics(Test) - a demo quantiser to cover the basic quantiser API
|
||
|
||
Copyright (C)
|
||
2011, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** is free software; you can redistribute it and/or modify it
|
||
under the terms of the GNU General Public License as published by the
|
||
Free Software Foundation; either version 2 of the License, or (at your
|
||
option) any later version. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file quantiser-basics-test.cpp
|
||
** unit test \ref QuantiserBasics_test
|
||
*/
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "lib/time/quantiser.hpp"
|
||
#include "lib/random.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
using lumiera::error::LUMIERA_ERROR_BOTTOM_VALUE;
|
||
using util::isnil;
|
||
using lib::rani;
|
||
|
||
|
||
|
||
namespace lib {
|
||
namespace time{
|
||
namespace test{
|
||
|
||
namespace {
|
||
|
||
const int MAX_FRAMES = 25*500;
|
||
const int DIRT_GRAIN = 50;
|
||
|
||
const FSecs F25(1,25); // duration of one PAL frame
|
||
|
||
inline Time
|
||
secs (int seconds)
|
||
{
|
||
return Time(FSecs(seconds));
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************//**
|
||
* @test cover the basic Quantiser API.
|
||
* This test uses a standalone quantiser implementation
|
||
* to demonstrate and verify the basic behaviour
|
||
* and the usage corner cases of a quantiser.
|
||
*
|
||
* In this most simple form, a quantiser is defined
|
||
* by the time reference point (origin) to use, and
|
||
* the frame rate (grid spacing). For each raw time
|
||
* value, the quantiser yields a time value aligned
|
||
* at the next lower frame bound. Besides that,
|
||
* time values are confined to be within
|
||
* the interval (Time::MIN, Time::Max)
|
||
*
|
||
* @see TimeQuantisation_test
|
||
*/
|
||
class QuantiserBasics_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
checkSimpleQuantisation();
|
||
coverQuantisationStandardCases();
|
||
coverQuantisationCornerCases();
|
||
}
|
||
|
||
|
||
void
|
||
checkSimpleQuantisation ()
|
||
{
|
||
FixedFrameQuantiser fixQ(25);
|
||
|
||
int frames = rani(MAX_FRAMES);
|
||
FSecs dirt = (F25 / (2 + rani(DIRT_GRAIN)));
|
||
|
||
Time rawTime = Time(frames*F25) + Duration(dirt);
|
||
|
||
CHECK (Time( frames *F25) <= rawTime);
|
||
CHECK (Time((frames+1)*F25) > rawTime);
|
||
|
||
Time quantTime (fixQ.gridLocal (rawTime));
|
||
|
||
CHECK (Time(frames*F25) == quantTime);
|
||
}
|
||
|
||
|
||
/** Test Quantiser
|
||
* allowing to use plain numbers.
|
||
* 1 Frame == 3 micro ticks */
|
||
struct TestQuant
|
||
: FixedFrameQuantiser
|
||
{
|
||
TestQuant (int origin=0)
|
||
: FixedFrameQuantiser( FrameRate(TimeValue::SCALE, 3 ), TimeValue(origin))
|
||
{ }
|
||
|
||
int
|
||
quant (int testPoint)
|
||
{
|
||
TimeVar quantised = this->gridLocal(TimeValue(testPoint));
|
||
return int(quantised);
|
||
}
|
||
};
|
||
|
||
void
|
||
coverQuantisationStandardCases()
|
||
{
|
||
TestQuant q0;
|
||
TestQuant q1(1);
|
||
|
||
CHECK ( 6 == q0.quant(7) );
|
||
CHECK ( 6 == q0.quant(6) );
|
||
CHECK ( 3 == q0.quant(5) );
|
||
CHECK ( 3 == q0.quant(4) );
|
||
CHECK ( 3 == q0.quant(3) );
|
||
CHECK ( 0 == q0.quant(2) );
|
||
CHECK ( 0 == q0.quant(1) );
|
||
CHECK ( 0 == q0.quant(0) );
|
||
CHECK (-3 == q0.quant(-1));
|
||
CHECK (-3 == q0.quant(-2));
|
||
CHECK (-3 == q0.quant(-3));
|
||
CHECK (-6 == q0.quant(-4));
|
||
|
||
CHECK ( 6 == q1.quant(7) );
|
||
CHECK ( 3 == q1.quant(6) );
|
||
CHECK ( 3 == q1.quant(5) );
|
||
CHECK ( 3 == q1.quant(4) );
|
||
CHECK ( 0 == q1.quant(3) );
|
||
CHECK ( 0 == q1.quant(2) );
|
||
CHECK ( 0 == q1.quant(1) );
|
||
CHECK (-3 == q1.quant(0) );
|
||
CHECK (-3 == q1.quant(-1));
|
||
CHECK (-3 == q1.quant(-2));
|
||
CHECK (-6 == q1.quant(-3));
|
||
CHECK (-6 == q1.quant(-4));
|
||
}
|
||
|
||
|
||
void
|
||
coverQuantisationCornerCases()
|
||
{
|
||
// origin at lower end of the time range
|
||
FixedFrameQuantiser case1 (1, Time::MIN);
|
||
CHECK (secs(0) == case1.gridLocal(Time::MIN ));
|
||
CHECK (secs(0) == case1.gridLocal(Time::MIN +TimeValue(1) ));
|
||
CHECK (secs(1) == case1.gridLocal(Time::MIN +secs(1) ));
|
||
CHECK (Time::MAX -secs(1) > case1.gridLocal( secs(-1) ));
|
||
CHECK (Time::MAX -secs(1) <= case1.gridLocal( secs (0) ));
|
||
CHECK (Time::MAX > case1.gridLocal( secs (0) ));
|
||
CHECK (Time::MAX == case1.gridLocal( secs(+1) ));
|
||
CHECK (Time::MAX == case1.gridLocal( secs(+2) ));
|
||
|
||
// origin at upper end of the time range
|
||
FixedFrameQuantiser case2 (1, Time::MAX);
|
||
CHECK (secs( 0) == case2.gridLocal(Time::MAX ));
|
||
CHECK (secs(-1) == case2.gridLocal(Time::MAX -TimeValue(1) )); // note: next lower frame
|
||
CHECK (secs(-1) == case2.gridLocal(Time::MAX -secs(1) )); // i.e. the same as a whole frame down
|
||
CHECK (Time::MIN +secs(1) < case2.gridLocal( secs(+2) ));
|
||
CHECK (Time::MIN +secs(1) >= case2.gridLocal( secs(+1) ));
|
||
CHECK (Time::MIN < case2.gridLocal( secs(+1) ));
|
||
CHECK (Time::MIN == case2.gridLocal( secs( 0) )); // note: because of downward truncating,
|
||
CHECK (Time::MIN == case2.gridLocal( secs(-1) )); // resulting values will already exceed
|
||
CHECK (Time::MIN == case2.gridLocal( secs(-2) )); // allowed range and thus will be clipped
|
||
|
||
// use very large frame with size of half the time range
|
||
Duration hugeFrame(Time::MAX);
|
||
FixedFrameQuantiser case3 (hugeFrame);
|
||
CHECK (Time::MIN == case3.gridLocal(Time::MIN ));
|
||
CHECK (Time::MIN == case3.gridLocal(Time::MIN +TimeValue(1) ));
|
||
CHECK (Time::MIN == case3.gridLocal( secs(-1) ));
|
||
CHECK (TimeValue(0) == case3.gridLocal( secs( 0) ));
|
||
CHECK (TimeValue(0) == case3.gridLocal( secs(+1) ));
|
||
CHECK (TimeValue(0) == case3.gridLocal(Time::MAX -TimeValue(1) ));
|
||
CHECK (Time::MAX == case3.gridLocal(Time::MAX ));
|
||
|
||
// now displacing this grid by +1sec....
|
||
FixedFrameQuantiser case4 (hugeFrame, secs(1));
|
||
CHECK (Time::MIN == case4.gridLocal(Time::MIN ));
|
||
CHECK (Time::MIN == case4.gridLocal(Time::MIN +TimeValue(1) )); // clipped...
|
||
CHECK (Time::MIN == case4.gridLocal(Time::MIN +secs(1) )); // but now exact (unclipped)
|
||
CHECK (Time::MIN == case4.gridLocal( secs(-1) ));
|
||
CHECK (Time::MIN == case4.gridLocal( secs( 0) ));
|
||
CHECK (TimeValue(0) == case4.gridLocal( secs(+1) )); //.....now exactly the frame number zero
|
||
CHECK (TimeValue(0) == case4.gridLocal(Time::MAX -TimeValue(1) ));
|
||
CHECK (TimeValue(0) == case4.gridLocal(Time::MAX )); //.......still truncated down to frame #0
|
||
|
||
// think big...
|
||
Duration superHuge{secs(12345) + hugeFrame};
|
||
Duration extraHuge{2*hugeFrame};
|
||
CHECK (extraHuge == Duration::MAX);
|
||
|
||
// Time::MAX < superHuge < Duration::Max is possible, but we can accommodate only one
|
||
FixedFrameQuantiser case5 (superHuge);
|
||
CHECK (TimeValue(0) == case5.gridLocal(Time::MAX ));
|
||
CHECK (TimeValue(0) == case5.gridLocal(Time::MAX -TimeValue(1) ));
|
||
CHECK (TimeValue(0) == case5.gridLocal( secs( 1) ));
|
||
CHECK (TimeValue(0) == case5.gridLocal( secs( 0) ));
|
||
CHECK (Time::MIN == case5.gridLocal( secs(-1) ));
|
||
CHECK (Time::MIN == case5.gridLocal(Time::MIN +TimeValue(1) ));
|
||
CHECK (Time::MIN == case5.gridLocal(Time::MIN ));
|
||
|
||
// now with offset
|
||
FixedFrameQuantiser case6 (superHuge, Time::MAX-secs(1));
|
||
CHECK (TimeValue(0) == case6.gridLocal(Time::MAX ));
|
||
CHECK (TimeValue(0) == case6.gridLocal(Time::MAX -TimeValue(1) ));
|
||
CHECK (TimeValue(0) == case6.gridLocal(Time::MAX -secs(1) ));
|
||
CHECK (Time::MIN == case6.gridLocal(Time::MAX -secs(2) ));
|
||
CHECK (Time::MIN == case6.gridLocal( secs( 1) ));
|
||
CHECK (Time::MIN == case6.gridLocal( secs(-12345) ));
|
||
CHECK (Time::MIN == case6.gridLocal( secs(-12345-1) ));
|
||
CHECK (Time::MIN == case6.gridLocal( secs(-12345-2) )); // this would be one frame lower, but is clipped
|
||
CHECK (Time::MIN == case6.gridLocal(Time::MIN +TimeValue(1) ));
|
||
CHECK (Time::MIN == case6.gridLocal(Time::MIN )); // same... unable to represent time points before Time::MIN
|
||
|
||
// maximum frame size is spanning the full time range
|
||
FixedFrameQuantiser case7 (extraHuge, Time::MIN+secs(1));
|
||
CHECK (TimeValue(0) == case7.gridLocal(Time::MAX )); // rounded down one frame, i.e. to origin
|
||
CHECK (TimeValue(0) == case7.gridLocal( secs( 0) ));
|
||
CHECK (TimeValue(0) == case7.gridLocal(Time::MIN+secs(2) ));
|
||
CHECK (TimeValue(0) == case7.gridLocal(Time::MIN+secs(1) )); // exactly at origin
|
||
CHECK (Time::MIN == case7.gridLocal(Time::MIN )); // one frame further down, but clipped to Time::MIN
|
||
|
||
// even larger frames aren't possible
|
||
Duration not_really_larger(secs(10000) + extraHuge);
|
||
CHECK (extraHuge == not_really_larger);
|
||
|
||
// frame sizes below the time micro grid get trapped
|
||
long subAtomic = 2*TimeValue::SCALE; // too small for this universe...
|
||
VERIFY_ERROR (BOTTOM_VALUE, FixedFrameQuantiser quark(subAtomic) );
|
||
VERIFY_ERROR (BOTTOM_VALUE, FixedFrameQuantiser quark(Duration (FSecs (1,subAtomic))) );
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (QuantiserBasics_test, "unit common");
|
||
|
||
|
||
|
||
}}} // namespace lib::time::test
|