OpenShot Library | libopenshot-audio  0.2.0
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 #if JUCE_UNIT_TESTS
88 
89 class MPEValueTests : public UnitTest
90 {
91 public:
92  MPEValueTests() : UnitTest ("MPEValue class", "MIDI/MPE") {}
93 
94  void runTest() override
95  {
96  beginTest ("comparison operator");
97  {
98  MPEValue value1 = MPEValue::from7BitInt (7);
99  MPEValue value2 = MPEValue::from7BitInt (7);
100  MPEValue value3 = MPEValue::from7BitInt (8);
101 
102  expect (value1 == value1);
103  expect (value1 == value2);
104  expect (value1 != value3);
105  }
106 
107  beginTest ("special values");
108  {
109  expectEquals (MPEValue::minValue().as7BitInt(), 0);
110  expectEquals (MPEValue::minValue().as14BitInt(), 0);
111 
112  expectEquals (MPEValue::centreValue().as7BitInt(), 64);
113  expectEquals (MPEValue::centreValue().as14BitInt(), 8192);
114 
115  expectEquals (MPEValue::maxValue().as7BitInt(), 127);
116  expectEquals (MPEValue::maxValue().as14BitInt(), 16383);
117  }
118 
119  beginTest ("zero/minimum value");
120  {
121  expectValuesConsistent (MPEValue::from7BitInt (0), 0, 0, -1.0f, 0.0f);
122  expectValuesConsistent (MPEValue::from14BitInt (0), 0, 0, -1.0f, 0.0f);
123  }
124 
125  beginTest ("maximum value");
126  {
127  expectValuesConsistent (MPEValue::from7BitInt (127), 127, 16383, 1.0f, 1.0f);
128  expectValuesConsistent (MPEValue::from14BitInt (16383), 127, 16383, 1.0f, 1.0f);
129  }
130 
131  beginTest ("centre value");
132  {
133  expectValuesConsistent (MPEValue::from7BitInt (64), 64, 8192, 0.0f, 0.5f);
134  expectValuesConsistent (MPEValue::from14BitInt (8192), 64, 8192, 0.0f, 0.5f);
135  }
136 
137  beginTest ("value halfway between min and centre");
138  {
139  expectValuesConsistent (MPEValue::from7BitInt (32), 32, 4096, -0.5f, 0.25f);
140  expectValuesConsistent (MPEValue::from14BitInt (4096), 32, 4096, -0.5f, 0.25f);
141  }
142  }
143 
144 private:
145  //==============================================================================
146  void expectValuesConsistent (MPEValue value,
147  int expectedValueAs7BitInt,
148  int expectedValueAs14BitInt,
149  float expectedValueAsSignedFloat,
150  float expectedValueAsUnsignedFloat)
151  {
152  expectEquals (value.as7BitInt(), expectedValueAs7BitInt);
153  expectEquals (value.as14BitInt(), expectedValueAs14BitInt);
154  expectFloatWithinRelativeError (value.asSignedFloat(), expectedValueAsSignedFloat, 0.0001f);
155  expectFloatWithinRelativeError (value.asUnsignedFloat(), expectedValueAsUnsignedFloat, 0.0001f);
156  }
157 
158  //==============================================================================
159  void expectFloatWithinRelativeError (float actualValue, float expectedValue, float maxRelativeError)
160  {
161  const float maxAbsoluteError = jmax (1.0f, std::abs (expectedValue)) * maxRelativeError;
162  expect (std::abs (expectedValue - actualValue) < maxAbsoluteError);
163  }
164 };
165 
166 static MPEValueTests MPEValueUnitTests;
167 
168 #endif // JUCE_UNIT_TESTS
169 
170 } // namespace juce
juce::MPEValue::as7BitInt
int as7BitInt() const noexcept
Retrieves the current value as an integer between 0 and 127.
Definition: juce_MPEValue.cpp:51
juce::MPEValue::operator!=
bool operator!=(const MPEValue &other) const noexcept
Returns true if two values are not equal.
Definition: juce_MPEValue.cpp:80
juce::MPEValue::asUnsignedFloat
float asUnsignedFloat() const noexcept
Retrieves the current value mapped to a float between 0.0f and 1.0f.
Definition: juce_MPEValue.cpp:69
juce::MPEValue::minValue
static MPEValue minValue() noexcept
Constructs an MPEValue corresponding to the minimum value.
Definition: juce_MPEValue.cpp:47
juce::MPEValue::from7BitInt
static MPEValue from7BitInt(int value) noexcept
Constructs an MPEValue from an integer between 0 and 127 (using 7-bit precision).
Definition: juce_MPEValue.cpp:30
juce::MPEValue
This class represents a single value for any of the MPE dimensions of control.
Definition: juce_MPEValue.h:40
juce::MPEValue::maxValue
static MPEValue maxValue() noexcept
Constructs an MPEValue corresponding to the maximum value.
Definition: juce_MPEValue.cpp:49
juce::MPEValue::operator==
bool operator==(const MPEValue &other) const noexcept
Returns true if two values are equal.
Definition: juce_MPEValue.cpp:75
juce::MPEValue::as14BitInt
int as14BitInt() const noexcept
Retrieves the current value as an integer between 0 and 16383.
Definition: juce_MPEValue.cpp:56
juce::MPEValue::from14BitInt
static MPEValue from14BitInt(int value) noexcept
Constructs an MPEValue from an integer between 0 and 16383 (using 14-bit precision).
Definition: juce_MPEValue.cpp:40
juce::MPEValue::asSignedFloat
float asSignedFloat() const noexcept
Retrieves the current value mapped to a float between -1.0f and 1.0f.
Definition: juce_MPEValue.cpp:62
juce::UnitTest
This is a base class for classes that perform a unit test.
Definition: juce_UnitTest.h:73
juce::MPEValue::MPEValue
MPEValue() noexcept
Default constructor.
Definition: juce_MPEValue.cpp:26
juce::MPEValue::centreValue
static MPEValue centreValue() noexcept
Constructs an MPEValue corresponding to the centre value.
Definition: juce_MPEValue.cpp:48