OpenShot Library | OpenShotAudio  0.2.2
juce_MPEValue.cpp
1 /*
2  ==============================================================================
3 
4  This file is part of the JUCE library.
5  Copyright (c) 2017 - ROLI Ltd.
6 
7  JUCE is an open source library subject to commercial or open-source
8  licensing.
9 
10  The code included in this file is provided under the terms of the ISC license
11  http://www.isc.org/downloads/software-support-policy/isc-license. Permission
12  To use, copy, modify, and/or distribute this software for any purpose with or
13  without fee is hereby granted provided that the above copyright notice and
14  this permission notice appear in all copies.
15 
16  JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
17  EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
18  DISCLAIMED.
19 
20  ==============================================================================
21 */
22 
23 namespace juce
24 {
25 
26 MPEValue::MPEValue() noexcept {}
27 MPEValue::MPEValue (int value) : normalisedValue (value) {}
28 
29 //==============================================================================
30 MPEValue MPEValue::from7BitInt (int value) noexcept
31 {
32  jassert (value >= 0 && value <= 127);
33 
34  auto valueAs14Bit = value <= 64 ? value << 7
35  : int (jmap<float> (float (value - 64), 0.0f, 63.0f, 0.0f, 8191.0f)) + 8192;
36 
37  return { valueAs14Bit };
38 }
39 
40 MPEValue MPEValue::from14BitInt (int value) noexcept
41 {
42  jassert (value >= 0 && value <= 16383);
43  return { value };
44 }
45 
46 //==============================================================================
50 
51 int MPEValue::as7BitInt() const noexcept
52 {
53  return normalisedValue >> 7;
54 }
55 
56 int MPEValue::as14BitInt() const noexcept
57 {
58  return normalisedValue;
59 }
60 
61 //==============================================================================
62 float MPEValue::asSignedFloat() const noexcept
63 {
64  return (normalisedValue < 8192)
65  ? jmap<float> (float (normalisedValue), 0.0f, 8192.0f, -1.0f, 0.0f)
66  : jmap<float> (float (normalisedValue), 8192.0f, 16383.0f, 0.0f, 1.0f);
67 }
68 
69 float MPEValue::asUnsignedFloat() const noexcept
70 {
71  return jmap<float> (float (normalisedValue), 0.0f, 16383.0f, 0.0f, 1.0f);
72 }
73 
74 //==============================================================================
75 bool MPEValue::operator== (const MPEValue& other) const noexcept
76 {
77  return normalisedValue == other.normalisedValue;
78 }
79 
80 bool MPEValue::operator!= (const MPEValue& other) const noexcept
81 {
82  return ! operator== (other);
83 }
84 
85 
86 //==============================================================================
87 //==============================================================================
88 #if JUCE_UNIT_TESTS
89 
90 class MPEValueTests : public UnitTest
91 {
92 public:
93  MPEValueTests()
94  : UnitTest ("MPEValue class", UnitTestCategories::midi)
95  {}
96 
97  void runTest() override
98  {
99  beginTest ("comparison operator");
100  {
101  MPEValue value1 = MPEValue::from7BitInt (7);
102  MPEValue value2 = MPEValue::from7BitInt (7);
103  MPEValue value3 = MPEValue::from7BitInt (8);
104 
105  expect (value1 == value1);
106  expect (value1 == value2);
107  expect (value1 != value3);
108  }
109 
110  beginTest ("special values");
111  {
112  expectEquals (MPEValue::minValue().as7BitInt(), 0);
113  expectEquals (MPEValue::minValue().as14BitInt(), 0);
114 
115  expectEquals (MPEValue::centreValue().as7BitInt(), 64);
116  expectEquals (MPEValue::centreValue().as14BitInt(), 8192);
117 
118  expectEquals (MPEValue::maxValue().as7BitInt(), 127);
119  expectEquals (MPEValue::maxValue().as14BitInt(), 16383);
120  }
121 
122  beginTest ("zero/minimum value");
123  {
124  expectValuesConsistent (MPEValue::from7BitInt (0), 0, 0, -1.0f, 0.0f);
125  expectValuesConsistent (MPEValue::from14BitInt (0), 0, 0, -1.0f, 0.0f);
126  }
127 
128  beginTest ("maximum value");
129  {
130  expectValuesConsistent (MPEValue::from7BitInt (127), 127, 16383, 1.0f, 1.0f);
131  expectValuesConsistent (MPEValue::from14BitInt (16383), 127, 16383, 1.0f, 1.0f);
132  }
133 
134  beginTest ("centre value");
135  {
136  expectValuesConsistent (MPEValue::from7BitInt (64), 64, 8192, 0.0f, 0.5f);
137  expectValuesConsistent (MPEValue::from14BitInt (8192), 64, 8192, 0.0f, 0.5f);
138  }
139 
140  beginTest ("value halfway between min and centre");
141  {
142  expectValuesConsistent (MPEValue::from7BitInt (32), 32, 4096, -0.5f, 0.25f);
143  expectValuesConsistent (MPEValue::from14BitInt (4096), 32, 4096, -0.5f, 0.25f);
144  }
145  }
146 
147 private:
148  //==============================================================================
149  void expectValuesConsistent (MPEValue value,
150  int expectedValueAs7BitInt,
151  int expectedValueAs14BitInt,
152  float expectedValueAsSignedFloat,
153  float expectedValueAsUnsignedFloat)
154  {
155  expectEquals (value.as7BitInt(), expectedValueAs7BitInt);
156  expectEquals (value.as14BitInt(), expectedValueAs14BitInt);
157  expectFloatWithinRelativeError (value.asSignedFloat(), expectedValueAsSignedFloat, 0.0001f);
158  expectFloatWithinRelativeError (value.asUnsignedFloat(), expectedValueAsUnsignedFloat, 0.0001f);
159  }
160 
161  //==============================================================================
162  void expectFloatWithinRelativeError (float actualValue, float expectedValue, float maxRelativeError)
163  {
164  const float maxAbsoluteError = jmax (1.0f, std::abs (expectedValue)) * maxRelativeError;
165  expect (std::abs (expectedValue - actualValue) < maxAbsoluteError);
166  }
167 };
168 
169 static MPEValueTests MPEValueUnitTests;
170 
171 #endif
172 
173 } // namespace juce
bool operator==(const MPEValue &other) const noexcept
Returns true if two values are equal.
MPEValue() noexcept
Default constructor.
static MPEValue from7BitInt(int value) noexcept
Constructs an MPEValue from an integer between 0 and 127 (using 7-bit precision). ...
float asSignedFloat() const noexcept
Retrieves the current value mapped to a float between -1.0f and 1.0f.
int as14BitInt() const noexcept
Retrieves the current value as an integer between 0 and 16383.
This is a base class for classes that perform a unit test.
Definition: juce_UnitTest.h:73
int as7BitInt() const noexcept
Retrieves the current value as an integer between 0 and 127.
static MPEValue centreValue() noexcept
Constructs an MPEValue corresponding to the centre value.
static MPEValue maxValue() noexcept
Constructs an MPEValue corresponding to the maximum value.
bool operator!=(const MPEValue &other) const noexcept
Returns true if two values are not equal.
float asUnsignedFloat() const noexcept
Retrieves the current value mapped to a float between 0.0f and 1.0f.
static MPEValue from14BitInt(int value) noexcept
Constructs an MPEValue from an integer between 0 and 16383 (using 14-bit precision).
This class represents a single value for any of the MPE dimensions of control.
Definition: juce_MPEValue.h:40
static MPEValue minValue() noexcept
Constructs an MPEValue corresponding to the minimum value.