/src/LAME-fuzzers/fuzzer-encoder.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | /* LAME encoder fuzzer by Guido Vranken <guidovranken@gmail.com> */ |
2 | | |
3 | | #include <cmath> |
4 | | #include <cstdint> |
5 | | #include <cstdlib> |
6 | | #include <fuzzing/datasource/datasource.hpp> |
7 | | #include <fuzzing/memory.hpp> |
8 | | #include <lame.h> |
9 | | #include <limits> |
10 | | #include <memory> |
11 | | #include <sstream> |
12 | | #include <stdexcept> |
13 | | #include <string> |
14 | | |
15 | | #ifdef MSAN |
16 | | extern "C" { |
17 | | void __msan_allocated_memory(const volatile void* data, size_t size); |
18 | | } |
19 | | #endif |
20 | | |
21 | | using fuzzing::datasource::Datasource; |
22 | | |
23 | | namespace limits { |
24 | | template <size_t Min, size_t Max> |
25 | | class Limit { |
26 | | static_assert(Min <= Max); |
27 | | |
28 | | public: |
29 | 26 | Limit(void) { }limits::Limit<1ul, 1048576ul>::Limit() Line | Count | Source | 29 | 2 | Limit(void) { } |
limits::Limit<1ul, 1024ul>::Limit() Line | Count | Source | 29 | 10 | Limit(void) { } |
limits::Limit<100ul, 1000000ul>::Limit() Line | Count | Source | 29 | 2 | Limit(void) { } |
limits::Limit<0ul, 9ul>::Limit() Line | Count | Source | 29 | 2 | Limit(void) { } |
limits::Limit<0ul, 1000000ul>::Limit() Line | Count | Source | 29 | 2 | Limit(void) { } |
limits::Limit<1000ul, 1000000ul>::Limit() Line | Count | Source | 29 | 6 | Limit(void) { } |
limits::Limit<1ul, 100ul>::Limit() Line | Count | Source | 29 | 2 | Limit(void) { } |
|
30 | | |
31 | 30.0k | size_t Test(const size_t val) const { |
32 | 30.0k | if ( val < Min || val > Max ) { |
33 | | /* If not within bounds, default to the minimum allowed value */ |
34 | 17.3k | return Min; |
35 | 17.3k | } |
36 | | |
37 | 12.7k | return val; |
38 | 30.0k | } limits::Limit<1ul, 1048576ul>::Test(unsigned long) const Line | Count | Source | 31 | 7.28k | size_t Test(const size_t val) const { | 32 | 7.28k | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 2.87k | return Min; | 35 | 2.87k | } | 36 | | | 37 | 4.40k | return val; | 38 | 7.28k | } |
limits::Limit<1ul, 1024ul>::Test(unsigned long) const Line | Count | Source | 31 | 7.24k | size_t Test(const size_t val) const { | 32 | 7.24k | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 4.75k | return Min; | 35 | 4.75k | } | 36 | | | 37 | 2.49k | return val; | 38 | 7.24k | } |
limits::Limit<0ul, 9ul>::Test(unsigned long) const Line | Count | Source | 31 | 6.60k | size_t Test(const size_t val) const { | 32 | 6.60k | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 3.93k | return Min; | 35 | 3.93k | } | 36 | | | 37 | 2.67k | return val; | 38 | 6.60k | } |
limits::Limit<100ul, 1000000ul>::Test(unsigned long) const Line | Count | Source | 31 | 6.59k | size_t Test(const size_t val) const { | 32 | 6.59k | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 4.26k | return Min; | 35 | 4.26k | } | 36 | | | 37 | 2.33k | return val; | 38 | 6.59k | } |
limits::Limit<0ul, 1000000ul>::Test(unsigned long) const Line | Count | Source | 31 | 785 | size_t Test(const size_t val) const { | 32 | 785 | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 297 | return Min; | 35 | 297 | } | 36 | | | 37 | 488 | return val; | 38 | 785 | } |
limits::Limit<1000ul, 1000000ul>::Test(unsigned long) const Line | Count | Source | 31 | 1.57k | size_t Test(const size_t val) const { | 32 | 1.57k | if ( val < Min || val > Max ) { | 33 | | /* If not within bounds, default to the minimum allowed value */ | 34 | 1.20k | return Min; | 35 | 1.20k | } | 36 | | | 37 | 372 | return val; | 38 | 1.57k | } |
|
39 | | |
40 | | template <typename T = uint32_t> |
41 | 30.1k | size_t Generate(fuzzing::datasource::Datasource& ds) { |
42 | 30.1k | const size_t ret = ds.Get<T>(); |
43 | 30.1k | return Test(ret); |
44 | 30.1k | } unsigned long limits::Limit<1ul, 1048576ul>::Generate<unsigned int>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 7.34k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 7.34k | const size_t ret = ds.Get<T>(); | 43 | 7.34k | return Test(ret); | 44 | 7.34k | } |
unsigned long limits::Limit<1ul, 1024ul>::Generate<unsigned char>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 1.28k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 1.28k | const size_t ret = ds.Get<T>(); | 43 | 1.28k | return Test(ret); | 44 | 1.28k | } |
unsigned long limits::Limit<1ul, 1024ul>::Generate<unsigned int>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 5.97k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 5.97k | const size_t ret = ds.Get<T>(); | 43 | 5.97k | return Test(ret); | 44 | 5.97k | } |
unsigned long limits::Limit<0ul, 9ul>::Generate<unsigned char>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 6.60k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 6.60k | const size_t ret = ds.Get<T>(); | 43 | 6.60k | return Test(ret); | 44 | 6.60k | } |
unsigned long limits::Limit<100ul, 1000000ul>::Generate<unsigned int>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 6.60k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 6.60k | const size_t ret = ds.Get<T>(); | 43 | 6.60k | return Test(ret); | 44 | 6.60k | } |
unsigned long limits::Limit<0ul, 1000000ul>::Generate<unsigned int>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 786 | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 786 | const size_t ret = ds.Get<T>(); | 43 | 786 | return Test(ret); | 44 | 786 | } |
unsigned long limits::Limit<1000ul, 1000000ul>::Generate<unsigned int>(fuzzing::datasource::Datasource&) Line | Count | Source | 41 | 1.57k | size_t Generate(fuzzing::datasource::Datasource& ds) { | 42 | 1.57k | const size_t ret = ds.Get<T>(); | 43 | 1.57k | return Test(ret); | 44 | 1.57k | } |
|
45 | | }; |
46 | | |
47 | | /* Set these to acceptable min/max limits */ |
48 | | static Limit<1, 1024*1024> OutBufferSize; |
49 | | static Limit<1, 1024> MinBitrate; |
50 | | static Limit<1, 1024> MaxBitrate; |
51 | | static Limit<1, 1024> VBRQ; |
52 | | static Limit<1, 1024> ABRBitrate; |
53 | | static Limit<1, 1024> CBRBitrate; |
54 | | static Limit<100, 1000000> OutSamplerate; |
55 | | static Limit<0, 9> Quality; |
56 | | static Limit<0, 1000000> LowpassFrequency; |
57 | | static Limit<1000, 1000000> LowpassWidth; |
58 | | static Limit<1000, 1000000> HighpassFrequency; |
59 | | static Limit<1000, 1000000> HighpassWidth; |
60 | | static Limit<1, 100> CompressionRatio; |
61 | | } |
62 | | |
63 | 24.5k | #define _(expr) Debug ? printf("%s\n", #expr) : 0; expr; |
64 | | |
65 | | /* Unspecialized method, for all types other than |
66 | | * float and double; do nothing. |
67 | | */ |
68 | 113M | template <typename T> bool isNAN(const T& val) { |
69 | 113M | (void)val; |
70 | | |
71 | 113M | return false; |
72 | 113M | } bool isNAN<short>(short const&) Line | Count | Source | 68 | 108M | template <typename T> bool isNAN(const T& val) { | 69 | 108M | (void)val; | 70 | | | 71 | 108M | return false; | 72 | 108M | } |
bool isNAN<int>(int const&) Line | Count | Source | 68 | 3.05M | template <typename T> bool isNAN(const T& val) { | 69 | 3.05M | (void)val; | 70 | | | 71 | 3.05M | return false; | 72 | 3.05M | } |
bool isNAN<long>(long const&) Line | Count | Source | 68 | 1.71M | template <typename T> bool isNAN(const T& val) { | 69 | 1.71M | (void)val; | 70 | | | 71 | 1.71M | return false; | 72 | 1.71M | } |
|
73 | | |
74 | 4.76M | template <> bool isNAN<float>(const float& val) { |
75 | 4.76M | return std::isnan(val); |
76 | 4.76M | } |
77 | | |
78 | 1.77M | template <> bool isNAN<double>(const double& val) { |
79 | 1.77M | return std::isnan(val); |
80 | 1.77M | } |
81 | | |
82 | 0 | std::string debug_define_size_t(const std::string name, const size_t val) { |
83 | 0 | return "const size_t " + name + " = " + std::to_string(val) + ";"; |
84 | 0 | } |
85 | | |
86 | | template <typename T> |
87 | | struct DebugDefineArray { |
88 | 0 | static std::string Str(const std::string name, const std::string typeName, const T* inData, const size_t inDataSize, const bool indent) { |
89 | 0 | std::stringstream ret; |
90 | |
|
91 | 0 | if ( indent ) { |
92 | 0 | ret << "\t"; |
93 | 0 | } |
94 | |
|
95 | 0 | ret << "const " << typeName << " " << name << "[] = {\n"; |
96 | |
|
97 | 0 | if ( indent ) { |
98 | 0 | ret << "\t"; |
99 | 0 | } |
100 | |
|
101 | 0 | for (size_t i = 0; i < inDataSize; i++) { |
102 | 0 | if ( i && !(i % 16) ) { |
103 | 0 | ret << "\n"; |
104 | 0 | if ( indent ) { |
105 | 0 | ret << "\t"; |
106 | 0 | } |
107 | 0 | } |
108 | |
|
109 | 0 | ret << "\t" << std::to_string(inData[i]) << ", "; |
110 | 0 | } |
111 | 0 | ret << "\n"; |
112 | |
|
113 | 0 | if ( indent ) { |
114 | 0 | ret << "\t"; |
115 | 0 | } |
116 | |
|
117 | 0 | ret << "};\n"; |
118 | |
|
119 | 0 | return ret.str(); |
120 | 0 | } Unexecuted instantiation: DebugDefineArray<short>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, short const*, unsigned long, bool) Unexecuted instantiation: DebugDefineArray<int>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, int const*, unsigned long, bool) Unexecuted instantiation: DebugDefineArray<long>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, long const*, unsigned long, bool) Unexecuted instantiation: DebugDefineArray<float>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, float const*, unsigned long, bool) Unexecuted instantiation: DebugDefineArray<double>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, double const*, unsigned long, bool) Unexecuted instantiation: DebugDefineArray<unsigned char>::Str(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned char const*, unsigned long, bool) |
121 | | }; |
122 | | |
123 | | class EncoderCoreBase { |
124 | | public: |
125 | 7.21k | EncoderCoreBase(void) { } |
126 | 7.21k | virtual ~EncoderCoreBase() { } |
127 | | virtual bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) = 0; |
128 | | }; |
129 | | |
130 | | template <typename T, bool Debug> |
131 | | class EncoderCore : public EncoderCoreBase { |
132 | | private: |
133 | | Datasource& ds; |
134 | | lame_global_flags* flags; |
135 | | |
136 | | std::vector< std::vector<T> > inDataV; |
137 | | typename std::vector< std::vector<T> >::iterator it; |
138 | | const bool useInterleavingFunction; |
139 | | const bool useIEEEFunction; |
140 | | |
141 | 7.19k | void getInputData(void) { |
142 | 433k | while ( ds.Get<bool>() ) { |
143 | 425k | const auto data = ds.GetData(0); |
144 | | |
145 | | /* Round to a multiple of sizeof(T) */ |
146 | 425k | const size_t copySize = data.size() - (data.size() % sizeof(T)); |
147 | | |
148 | 425k | std::vector<T> toInsert; |
149 | 425k | toInsert.resize( data.size() / sizeof(T) ); |
150 | | |
151 | 425k | memcpy(toInsert.data(), data.data(), copySize); |
152 | | |
153 | | /* Correct NAN values */ |
154 | 120M | for (size_t i = 0; i < toInsert.size(); i++) { |
155 | 120M | if ( isNAN(toInsert[i]) ) { |
156 | | /* If NaN, set to default value (0.0) */ |
157 | 156k | toInsert[i] = {}; |
158 | 156k | } |
159 | 120M | } |
160 | | |
161 | 425k | inDataV.push_back(toInsert); |
162 | 425k | } |
163 | | |
164 | 7.19k | it = inDataV.begin(); |
165 | 7.19k | } EncoderCore<short, false>::getInputData() Line | Count | Source | 141 | 4.24k | void getInputData(void) { | 142 | 63.7k | while ( ds.Get<bool>() ) { | 143 | 59.5k | const auto data = ds.GetData(0); | 144 | | | 145 | | /* Round to a multiple of sizeof(T) */ | 146 | 59.5k | const size_t copySize = data.size() - (data.size() % sizeof(T)); | 147 | | | 148 | 59.5k | std::vector<T> toInsert; | 149 | 59.5k | toInsert.resize( data.size() / sizeof(T) ); | 150 | | | 151 | 59.5k | memcpy(toInsert.data(), data.data(), copySize); | 152 | | | 153 | | /* Correct NAN values */ | 154 | 108M | for (size_t i = 0; i < toInsert.size(); i++) { | 155 | 108M | if ( isNAN(toInsert[i]) ) { | 156 | | /* If NaN, set to default value (0.0) */ | 157 | 0 | toInsert[i] = {}; | 158 | 0 | } | 159 | 108M | } | 160 | | | 161 | 59.5k | inDataV.push_back(toInsert); | 162 | 59.5k | } | 163 | | | 164 | 4.24k | it = inDataV.begin(); | 165 | 4.24k | } |
EncoderCore<int, false>::getInputData() Line | Count | Source | 141 | 597 | void getInputData(void) { | 142 | 51.5k | while ( ds.Get<bool>() ) { | 143 | 50.9k | const auto data = ds.GetData(0); | 144 | | | 145 | | /* Round to a multiple of sizeof(T) */ | 146 | 50.9k | const size_t copySize = data.size() - (data.size() % sizeof(T)); | 147 | | | 148 | 50.9k | std::vector<T> toInsert; | 149 | 50.9k | toInsert.resize( data.size() / sizeof(T) ); | 150 | | | 151 | 50.9k | memcpy(toInsert.data(), data.data(), copySize); | 152 | | | 153 | | /* Correct NAN values */ | 154 | 3.10M | for (size_t i = 0; i < toInsert.size(); i++) { | 155 | 3.05M | if ( isNAN(toInsert[i]) ) { | 156 | | /* If NaN, set to default value (0.0) */ | 157 | 0 | toInsert[i] = {}; | 158 | 0 | } | 159 | 3.05M | } | 160 | | | 161 | 50.9k | inDataV.push_back(toInsert); | 162 | 50.9k | } | 163 | | | 164 | 597 | it = inDataV.begin(); | 165 | 597 | } |
EncoderCore<long, false>::getInputData() Line | Count | Source | 141 | 911 | void getInputData(void) { | 142 | 132k | while ( ds.Get<bool>() ) { | 143 | 131k | const auto data = ds.GetData(0); | 144 | | | 145 | | /* Round to a multiple of sizeof(T) */ | 146 | 131k | const size_t copySize = data.size() - (data.size() % sizeof(T)); | 147 | | | 148 | 131k | std::vector<T> toInsert; | 149 | 131k | toInsert.resize( data.size() / sizeof(T) ); | 150 | | | 151 | 131k | memcpy(toInsert.data(), data.data(), copySize); | 152 | | | 153 | | /* Correct NAN values */ | 154 | 1.85M | for (size_t i = 0; i < toInsert.size(); i++) { | 155 | 1.71M | if ( isNAN(toInsert[i]) ) { | 156 | | /* If NaN, set to default value (0.0) */ | 157 | 0 | toInsert[i] = {}; | 158 | 0 | } | 159 | 1.71M | } | 160 | | | 161 | 131k | inDataV.push_back(toInsert); | 162 | 131k | } | 163 | | | 164 | 911 | it = inDataV.begin(); | 165 | 911 | } |
EncoderCore<float, false>::getInputData() Line | Count | Source | 141 | 838 | void getInputData(void) { | 142 | 52.1k | while ( ds.Get<bool>() ) { | 143 | 51.3k | const auto data = ds.GetData(0); | 144 | | | 145 | | /* Round to a multiple of sizeof(T) */ | 146 | 51.3k | const size_t copySize = data.size() - (data.size() % sizeof(T)); | 147 | | | 148 | 51.3k | std::vector<T> toInsert; | 149 | 51.3k | toInsert.resize( data.size() / sizeof(T) ); | 150 | | | 151 | 51.3k | memcpy(toInsert.data(), data.data(), copySize); | 152 | | | 153 | | /* Correct NAN values */ | 154 | 4.81M | for (size_t i = 0; i < toInsert.size(); i++) { | 155 | 4.76M | if ( isNAN(toInsert[i]) ) { | 156 | | /* If NaN, set to default value (0.0) */ | 157 | 111k | toInsert[i] = {}; | 158 | 111k | } | 159 | 4.76M | } | 160 | | | 161 | 51.3k | inDataV.push_back(toInsert); | 162 | 51.3k | } | 163 | | | 164 | 838 | it = inDataV.begin(); | 165 | 838 | } |
EncoderCore<double, false>::getInputData() Line | Count | Source | 141 | 606 | void getInputData(void) { | 142 | 133k | while ( ds.Get<bool>() ) { | 143 | 132k | const auto data = ds.GetData(0); | 144 | | | 145 | | /* Round to a multiple of sizeof(T) */ | 146 | 132k | const size_t copySize = data.size() - (data.size() % sizeof(T)); | 147 | | | 148 | 132k | std::vector<T> toInsert; | 149 | 132k | toInsert.resize( data.size() / sizeof(T) ); | 150 | | | 151 | 132k | memcpy(toInsert.data(), data.data(), copySize); | 152 | | | 153 | | /* Correct NAN values */ | 154 | 1.91M | for (size_t i = 0; i < toInsert.size(); i++) { | 155 | 1.77M | if ( isNAN(toInsert[i]) ) { | 156 | | /* If NaN, set to default value (0.0) */ | 157 | 44.8k | toInsert[i] = {}; | 158 | 44.8k | } | 159 | 1.77M | } | 160 | | | 161 | 132k | inDataV.push_back(toInsert); | 162 | 132k | } | 163 | | | 164 | 606 | it = inDataV.begin(); | 165 | 606 | } |
Unexecuted instantiation: EncoderCore<short, true>::getInputData() Unexecuted instantiation: EncoderCore<int, true>::getInputData() Unexecuted instantiation: EncoderCore<long, true>::getInputData() Unexecuted instantiation: EncoderCore<float, true>::getInputData() Unexecuted instantiation: EncoderCore<double, true>::getInputData() |
166 | | |
167 | | template <typename _T, long Min, long Max> |
168 | | struct InputCorrect { |
169 | | static_assert(std::numeric_limits<_T>::lowest() <= Min); |
170 | | static_assert(std::numeric_limits<_T>::max() >= Max); |
171 | | |
172 | 3.76k | static void Correct(_T* inData, const size_t inDataSize) { |
173 | 3.76k | if ( inData == nullptr ) { |
174 | 831 | return; |
175 | 831 | } |
176 | | |
177 | 6.90M | for (size_t i = 0; i < inDataSize; i++) { |
178 | 6.90M | if ( inData[i] > Max ) { |
179 | 1.30M | inData[i] = Max; |
180 | 5.60M | } else if ( inData[i] < Min ) { |
181 | 1.44M | inData[i] = Min; |
182 | 1.44M | } |
183 | 6.90M | } |
184 | 2.93k | } EncoderCore<long, false>::InputCorrect<long, -32768l, 32768l>::Correct(long*, unsigned long) Line | Count | Source | 172 | 1.35k | static void Correct(_T* inData, const size_t inDataSize) { | 173 | 1.35k | if ( inData == nullptr ) { | 174 | 348 | return; | 175 | 348 | } | 176 | | | 177 | 1.39M | for (size_t i = 0; i < inDataSize; i++) { | 178 | 1.39M | if ( inData[i] > Max ) { | 179 | 744k | inData[i] = Max; | 180 | 744k | } else if ( inData[i] < Min ) { | 181 | 423k | inData[i] = Min; | 182 | 423k | } | 183 | 1.39M | } | 184 | 1.01k | } |
EncoderCore<float, false>::InputCorrect<float, -32768l, 32768l>::Correct(float*, unsigned long) Line | Count | Source | 172 | 624 | static void Correct(_T* inData, const size_t inDataSize) { | 173 | 624 | if ( inData == nullptr ) { | 174 | 109 | return; | 175 | 109 | } | 176 | | | 177 | 1.04M | for (size_t i = 0; i < inDataSize; i++) { | 178 | 1.04M | if ( inData[i] > Max ) { | 179 | 141k | inData[i] = Max; | 180 | 901k | } else if ( inData[i] < Min ) { | 181 | 175k | inData[i] = Min; | 182 | 175k | } | 183 | 1.04M | } | 184 | 515 | } |
EncoderCore<float, false>::InputCorrect<float, -1l, 1l>::Correct(float*, unsigned long) Line | Count | Source | 172 | 974 | static void Correct(_T* inData, const size_t inDataSize) { | 173 | 974 | if ( inData == nullptr ) { | 174 | 149 | return; | 175 | 149 | } | 176 | | | 177 | 3.01M | for (size_t i = 0; i < inDataSize; i++) { | 178 | 3.01M | if ( inData[i] > Max ) { | 179 | 301k | inData[i] = Max; | 180 | 2.71M | } else if ( inData[i] < Min ) { | 181 | 574k | inData[i] = Min; | 182 | 574k | } | 183 | 3.01M | } | 184 | 825 | } |
EncoderCore<double, false>::InputCorrect<double, -1l, 1l>::Correct(double*, unsigned long) Line | Count | Source | 172 | 805 | static void Correct(_T* inData, const size_t inDataSize) { | 173 | 805 | if ( inData == nullptr ) { | 174 | 225 | return; | 175 | 225 | } | 176 | | | 177 | 1.44M | for (size_t i = 0; i < inDataSize; i++) { | 178 | 1.44M | if ( inData[i] > Max ) { | 179 | 114k | inData[i] = Max; | 180 | 1.33M | } else if ( inData[i] < Min ) { | 181 | 276k | inData[i] = Min; | 182 | 276k | } | 183 | 1.44M | } | 184 | 580 | } |
Unexecuted instantiation: EncoderCore<long, true>::InputCorrect<long, -32768l, 32768l>::Correct(long*, unsigned long) Unexecuted instantiation: EncoderCore<float, true>::InputCorrect<float, -32768l, 32768l>::Correct(float*, unsigned long) Unexecuted instantiation: EncoderCore<float, true>::InputCorrect<float, -1l, 1l>::Correct(float*, unsigned long) Unexecuted instantiation: EncoderCore<double, true>::InputCorrect<double, -1l, 1l>::Correct(double*, unsigned long) |
185 | | }; |
186 | | |
187 | | template <typename T_, bool Debug_> |
188 | | struct EncodeSingle { |
189 | | static int encode( |
190 | | lame_global_flags* flags, |
191 | | T* inData, |
192 | | const size_t inDataSize, |
193 | | uint8_t* outBuffer, |
194 | | const size_t outBufferSize, |
195 | | bool useInterleavedFunction, |
196 | | bool useIEEEFunction); |
197 | | }; |
198 | | |
199 | | template<bool Debug_> struct EncodeSingle<short int, Debug_> { |
200 | | static int encode( |
201 | | lame_global_flags* flags, |
202 | | short int* inDataL, |
203 | | short int* inDataR, |
204 | | const size_t inDataSize, |
205 | | uint8_t* outBuffer, |
206 | | const size_t outBufferSize, |
207 | | bool useInterleavingFunction, |
208 | 7.17k | bool useIEEEFunction) { |
209 | | /* Not applicable for short int */ |
210 | 7.17k | (void)useIEEEFunction; |
211 | | |
212 | 7.17k | if ( useInterleavingFunction == false ) { |
213 | 4.72k | Debug ? printf("{\n") : 0; |
214 | | |
215 | 4.72k | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
216 | | |
217 | 4.72k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataL", "short int", inDataL, inDataSize, true).c_str()) : 0; |
218 | 4.72k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataR", "short int", inDataR, inDataSize, true).c_str()) : 0; |
219 | | |
220 | 4.72k | Debug ? |
221 | 0 | printf("\tlame_encode_buffer(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
222 | 4.72k | : 0; |
223 | | |
224 | 4.72k | const int ret = lame_encode_buffer(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
225 | | |
226 | 4.72k | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
227 | | |
228 | 4.72k | Debug ? printf("}\n") : 0; |
229 | | |
230 | 4.72k | return ret; |
231 | 4.72k | } else { |
232 | 2.45k | Debug ? printf("{\n") : 0; |
233 | | |
234 | 2.45k | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
235 | | |
236 | 2.45k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataL", "short int", inDataL, inDataSize * 2, true).c_str()) : 0; |
237 | | |
238 | 2.45k | Debug ? |
239 | 0 | printf("\tlame_encode_buffer_interleaved(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") |
240 | 2.45k | : 0; |
241 | | |
242 | 2.45k | const int ret = lame_encode_buffer_interleaved(flags, inDataL, inDataSize, outBuffer, outBufferSize); |
243 | | |
244 | 2.45k | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
245 | | |
246 | 2.45k | Debug ? printf("}\n") : 0; |
247 | | |
248 | 2.45k | return ret; |
249 | 2.45k | } |
250 | 7.17k | } EncoderCore<short, false>::EncodeSingle<short, false>::encode(lame_global_struct*, short*, short*, unsigned long, unsigned char*, unsigned long, bool, bool) Line | Count | Source | 208 | 7.17k | bool useIEEEFunction) { | 209 | | /* Not applicable for short int */ | 210 | 7.17k | (void)useIEEEFunction; | 211 | | | 212 | 7.17k | if ( useInterleavingFunction == false ) { | 213 | 4.72k | Debug ? printf("{\n") : 0; | 214 | | | 215 | 4.72k | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 216 | | | 217 | 4.72k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataL", "short int", inDataL, inDataSize, true).c_str()) : 0; | 218 | 4.72k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataR", "short int", inDataR, inDataSize, true).c_str()) : 0; | 219 | | | 220 | 4.72k | Debug ? | 221 | 0 | printf("\tlame_encode_buffer(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 222 | 4.72k | : 0; | 223 | | | 224 | 4.72k | const int ret = lame_encode_buffer(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 225 | | | 226 | 4.72k | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 227 | | | 228 | 4.72k | Debug ? printf("}\n") : 0; | 229 | | | 230 | 4.72k | return ret; | 231 | 4.72k | } else { | 232 | 2.45k | Debug ? printf("{\n") : 0; | 233 | | | 234 | 2.45k | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 235 | | | 236 | 2.45k | Debug ? printf("%s\n", DebugDefineArray<short int>::Str("inDataL", "short int", inDataL, inDataSize * 2, true).c_str()) : 0; | 237 | | | 238 | 2.45k | Debug ? | 239 | 0 | printf("\tlame_encode_buffer_interleaved(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") | 240 | 2.45k | : 0; | 241 | | | 242 | 2.45k | const int ret = lame_encode_buffer_interleaved(flags, inDataL, inDataSize, outBuffer, outBufferSize); | 243 | | | 244 | 2.45k | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 245 | | | 246 | 2.45k | Debug ? printf("}\n") : 0; | 247 | | | 248 | 2.45k | return ret; | 249 | 2.45k | } | 250 | 7.17k | } |
Unexecuted instantiation: EncoderCore<short, true>::EncodeSingle<short, true>::encode(lame_global_struct*, short*, short*, unsigned long, unsigned char*, unsigned long, bool, bool) |
251 | | }; |
252 | | |
253 | | template<bool Debug_> struct EncodeSingle<int, Debug_> { |
254 | | static int encode( |
255 | | lame_global_flags* flags, |
256 | | int* inDataL, |
257 | | int* inDataR, |
258 | | const size_t inDataSize, |
259 | | uint8_t* outBuffer, |
260 | | const size_t outBufferSize, |
261 | | bool useInterleavingFunction, |
262 | 412 | bool useIEEEFunction ) { |
263 | | /* Not applicable for int */ |
264 | 412 | (void)useIEEEFunction; |
265 | | |
266 | 412 | if ( useInterleavingFunction == false ) { |
267 | 292 | Debug ? printf("{\n") : 0; |
268 | | |
269 | 292 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
270 | | |
271 | 292 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataL", "int", inDataL, inDataSize, true).c_str()) : 0; |
272 | 292 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataR", "int", inDataR, inDataSize, true).c_str()) : 0; |
273 | | |
274 | 292 | Debug ? |
275 | 0 | printf("\tlame_encode_buffer_int(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
276 | 292 | : 0; |
277 | | |
278 | 292 | const int ret = lame_encode_buffer_int(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
279 | | |
280 | 292 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
281 | | |
282 | 292 | Debug ? printf("}\n") : 0; |
283 | | |
284 | 292 | return ret; |
285 | 292 | } else { |
286 | 120 | Debug ? printf("{\n") : 0; |
287 | | |
288 | 120 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
289 | | |
290 | 120 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataL", "int", inDataL, inDataSize * 2, true).c_str()) : 0; |
291 | | |
292 | 120 | Debug ? |
293 | 0 | printf("\tlame_encode_buffer_interleaved_int(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") |
294 | 120 | : 0; |
295 | | |
296 | 120 | const int ret = lame_encode_buffer_interleaved_int(flags, inDataL, inDataSize, outBuffer, outBufferSize); |
297 | | |
298 | 120 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
299 | | |
300 | 120 | Debug ? printf("}\n") : 0; |
301 | | |
302 | 120 | return ret; |
303 | 120 | } |
304 | 412 | } EncoderCore<int, false>::EncodeSingle<int, false>::encode(lame_global_struct*, int*, int*, unsigned long, unsigned char*, unsigned long, bool, bool) Line | Count | Source | 262 | 412 | bool useIEEEFunction ) { | 263 | | /* Not applicable for int */ | 264 | 412 | (void)useIEEEFunction; | 265 | | | 266 | 412 | if ( useInterleavingFunction == false ) { | 267 | 292 | Debug ? printf("{\n") : 0; | 268 | | | 269 | 292 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 270 | | | 271 | 292 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataL", "int", inDataL, inDataSize, true).c_str()) : 0; | 272 | 292 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataR", "int", inDataR, inDataSize, true).c_str()) : 0; | 273 | | | 274 | 292 | Debug ? | 275 | 0 | printf("\tlame_encode_buffer_int(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 276 | 292 | : 0; | 277 | | | 278 | 292 | const int ret = lame_encode_buffer_int(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 279 | | | 280 | 292 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 281 | | | 282 | 292 | Debug ? printf("}\n") : 0; | 283 | | | 284 | 292 | return ret; | 285 | 292 | } else { | 286 | 120 | Debug ? printf("{\n") : 0; | 287 | | | 288 | 120 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 289 | | | 290 | 120 | Debug ? printf("%s\n", DebugDefineArray<int>::Str("inDataL", "int", inDataL, inDataSize * 2, true).c_str()) : 0; | 291 | | | 292 | 120 | Debug ? | 293 | 0 | printf("\tlame_encode_buffer_interleaved_int(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") | 294 | 120 | : 0; | 295 | | | 296 | 120 | const int ret = lame_encode_buffer_interleaved_int(flags, inDataL, inDataSize, outBuffer, outBufferSize); | 297 | | | 298 | 120 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 299 | | | 300 | 120 | Debug ? printf("}\n") : 0; | 301 | | | 302 | 120 | return ret; | 303 | 120 | } | 304 | 412 | } |
Unexecuted instantiation: EncoderCore<int, true>::EncodeSingle<int, true>::encode(lame_global_struct*, int*, int*, unsigned long, unsigned char*, unsigned long, bool, bool) |
305 | | }; |
306 | | |
307 | | template<bool Debug_> struct EncodeSingle<long, Debug_> { |
308 | | static int encode( |
309 | | lame_global_flags* flags, |
310 | | long* inDataL, |
311 | | long* inDataR, |
312 | | const size_t inDataSize, |
313 | | uint8_t* outBuffer, |
314 | | const size_t outBufferSize, |
315 | | bool useInterleavingFunction, |
316 | 702 | bool useIEEEFunction) { |
317 | | /* Not applicable for long */ |
318 | 702 | (void)useIEEEFunction; |
319 | | |
320 | 702 | if ( useInterleavingFunction == false ) { |
321 | 679 | InputCorrect<long, -32768, 32768>::Correct(inDataL, inDataSize); |
322 | 679 | InputCorrect<long, -32768, 32768>::Correct(inDataR, inDataSize); |
323 | | |
324 | 679 | Debug ? printf("{\n") : 0; |
325 | | |
326 | 679 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
327 | | |
328 | 679 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataL", "long", inDataL, inDataSize, true).c_str()) : 0; |
329 | 679 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataR", "long", inDataR, inDataSize, true).c_str()) : 0; |
330 | | |
331 | 679 | Debug ? |
332 | 0 | printf("\tlame_encode_buffer_long(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
333 | 679 | : 0; |
334 | | |
335 | 679 | const int ret = lame_encode_buffer_long(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
336 | | |
337 | 679 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
338 | | |
339 | 679 | Debug ? printf("}\n") : 0; |
340 | | |
341 | 679 | return ret; |
342 | 679 | } else { |
343 | 23 | Debug ? printf("{\n") : 0; |
344 | | |
345 | 23 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
346 | | |
347 | 23 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataL", "long", inDataL, inDataSize, true).c_str()) : 0; |
348 | 23 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataR", "long", inDataR, inDataSize, true).c_str()) : 0; |
349 | | |
350 | 23 | Debug ? |
351 | 0 | printf("\tlame_encode_buffer_long2(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
352 | 23 | : 0; |
353 | | |
354 | | /* Not actually interleaved */ |
355 | 23 | const int ret = lame_encode_buffer_long2(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
356 | | |
357 | 23 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
358 | | |
359 | 23 | Debug ? printf("}\n") : 0; |
360 | | |
361 | 23 | return ret; |
362 | 23 | } |
363 | 702 | } EncoderCore<long, false>::EncodeSingle<long, false>::encode(lame_global_struct*, long*, long*, unsigned long, unsigned char*, unsigned long, bool, bool) Line | Count | Source | 316 | 702 | bool useIEEEFunction) { | 317 | | /* Not applicable for long */ | 318 | 702 | (void)useIEEEFunction; | 319 | | | 320 | 702 | if ( useInterleavingFunction == false ) { | 321 | 679 | InputCorrect<long, -32768, 32768>::Correct(inDataL, inDataSize); | 322 | 679 | InputCorrect<long, -32768, 32768>::Correct(inDataR, inDataSize); | 323 | | | 324 | 679 | Debug ? printf("{\n") : 0; | 325 | | | 326 | 679 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 327 | | | 328 | 679 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataL", "long", inDataL, inDataSize, true).c_str()) : 0; | 329 | 679 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataR", "long", inDataR, inDataSize, true).c_str()) : 0; | 330 | | | 331 | 679 | Debug ? | 332 | 0 | printf("\tlame_encode_buffer_long(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 333 | 679 | : 0; | 334 | | | 335 | 679 | const int ret = lame_encode_buffer_long(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 336 | | | 337 | 679 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 338 | | | 339 | 679 | Debug ? printf("}\n") : 0; | 340 | | | 341 | 679 | return ret; | 342 | 679 | } else { | 343 | 23 | Debug ? printf("{\n") : 0; | 344 | | | 345 | 23 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 346 | | | 347 | 23 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataL", "long", inDataL, inDataSize, true).c_str()) : 0; | 348 | 23 | Debug ? printf("%s\n", DebugDefineArray<long>::Str("inDataR", "long", inDataR, inDataSize, true).c_str()) : 0; | 349 | | | 350 | 23 | Debug ? | 351 | 0 | printf("\tlame_encode_buffer_long2(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 352 | 23 | : 0; | 353 | | | 354 | | /* Not actually interleaved */ | 355 | 23 | const int ret = lame_encode_buffer_long2(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 356 | | | 357 | 23 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 358 | | | 359 | 23 | Debug ? printf("}\n") : 0; | 360 | | | 361 | 23 | return ret; | 362 | 23 | } | 363 | 702 | } |
Unexecuted instantiation: EncoderCore<long, true>::EncodeSingle<long, true>::encode(lame_global_struct*, long*, long*, unsigned long, unsigned char*, unsigned long, bool, bool) |
364 | | }; |
365 | | |
366 | | template<bool Debug_> struct EncodeSingle<float, Debug_> { |
367 | | static int encode( |
368 | | lame_global_flags* flags, |
369 | | float* inDataL, |
370 | | float* inDataR, |
371 | | const size_t inDataSize, |
372 | | uint8_t* outBuffer, |
373 | | const size_t outBufferSize, |
374 | | bool useInterleavingFunction, |
375 | 934 | bool useIEEEFunction) { |
376 | | |
377 | 934 | if ( useInterleavingFunction == false ) { |
378 | 665 | if ( useIEEEFunction == false ) { |
379 | 312 | InputCorrect<float, -32768, 32768>::Correct(inDataL, inDataSize); |
380 | 312 | InputCorrect<float, -32768, 32768>::Correct(inDataR, inDataSize); |
381 | | |
382 | 312 | Debug ? printf("{\n") : 0; |
383 | | |
384 | 312 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
385 | | |
386 | 312 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize, true).c_str()) : 0; |
387 | 312 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataR", "float", inDataR, inDataSize, true).c_str()) : 0; |
388 | | |
389 | 312 | Debug ? |
390 | 0 | printf("\tlame_encode_buffer_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
391 | 312 | : 0; |
392 | | |
393 | 312 | const int ret = lame_encode_buffer_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
394 | | |
395 | 312 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
396 | | |
397 | 312 | Debug ? printf("}\n") : 0; |
398 | | |
399 | 312 | return ret; |
400 | 353 | } else { |
401 | 353 | InputCorrect<float, -1, 1>::Correct(inDataL, inDataSize); |
402 | 353 | InputCorrect<float, -1, 1>::Correct(inDataR, inDataSize); |
403 | | |
404 | 353 | Debug ? printf("{\n") : 0; |
405 | | |
406 | 353 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
407 | | |
408 | 353 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize, true).c_str()) : 0; |
409 | 353 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataR", "float", inDataR, inDataSize, true).c_str()) : 0; |
410 | | |
411 | 353 | Debug ? |
412 | 0 | printf("\tlame_encode_buffer_ieee_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
413 | 353 | : 0; |
414 | | |
415 | 353 | const int ret = lame_encode_buffer_ieee_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
416 | | |
417 | 353 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
418 | | |
419 | 353 | Debug ? printf("}\n") : 0; |
420 | | |
421 | 353 | return ret; |
422 | 353 | } |
423 | 665 | } else { |
424 | 269 | if ( useIEEEFunction == true ) { |
425 | 268 | InputCorrect<float, -1, 1>::Correct(inDataL, inDataSize * 2); |
426 | | |
427 | 268 | Debug ? printf("{\n") : 0; |
428 | | |
429 | 268 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize * 2).c_str()) : 0; |
430 | | |
431 | 268 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize * 2, true).c_str()) : 0; |
432 | | |
433 | 268 | Debug ? |
434 | 0 | printf("\tlame_encode_buffer_interleaved_ieee_float(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") |
435 | 268 | : 0; |
436 | | |
437 | 268 | const int ret = lame_encode_buffer_interleaved_ieee_float(flags, inDataL, inDataSize, outBuffer, outBufferSize); |
438 | | |
439 | 268 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
440 | | |
441 | 268 | Debug ? printf("}\n") : 0; |
442 | | |
443 | 268 | return ret; |
444 | 268 | } else { |
445 | | /* No function for interleaved float */ |
446 | 1 | return -1; |
447 | 1 | } |
448 | 269 | } |
449 | 934 | } EncoderCore<float, false>::EncodeSingle<float, false>::encode(lame_global_struct*, float*, float*, unsigned long, unsigned char*, unsigned long, bool, bool) Line | Count | Source | 375 | 934 | bool useIEEEFunction) { | 376 | | | 377 | 934 | if ( useInterleavingFunction == false ) { | 378 | 665 | if ( useIEEEFunction == false ) { | 379 | 312 | InputCorrect<float, -32768, 32768>::Correct(inDataL, inDataSize); | 380 | 312 | InputCorrect<float, -32768, 32768>::Correct(inDataR, inDataSize); | 381 | | | 382 | 312 | Debug ? printf("{\n") : 0; | 383 | | | 384 | 312 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 385 | | | 386 | 312 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize, true).c_str()) : 0; | 387 | 312 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataR", "float", inDataR, inDataSize, true).c_str()) : 0; | 388 | | | 389 | 312 | Debug ? | 390 | 0 | printf("\tlame_encode_buffer_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 391 | 312 | : 0; | 392 | | | 393 | 312 | const int ret = lame_encode_buffer_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 394 | | | 395 | 312 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 396 | | | 397 | 312 | Debug ? printf("}\n") : 0; | 398 | | | 399 | 312 | return ret; | 400 | 353 | } else { | 401 | 353 | InputCorrect<float, -1, 1>::Correct(inDataL, inDataSize); | 402 | 353 | InputCorrect<float, -1, 1>::Correct(inDataR, inDataSize); | 403 | | | 404 | 353 | Debug ? printf("{\n") : 0; | 405 | | | 406 | 353 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 407 | | | 408 | 353 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize, true).c_str()) : 0; | 409 | 353 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataR", "float", inDataR, inDataSize, true).c_str()) : 0; | 410 | | | 411 | 353 | Debug ? | 412 | 0 | printf("\tlame_encode_buffer_ieee_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 413 | 353 | : 0; | 414 | | | 415 | 353 | const int ret = lame_encode_buffer_ieee_float(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 416 | | | 417 | 353 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 418 | | | 419 | 353 | Debug ? printf("}\n") : 0; | 420 | | | 421 | 353 | return ret; | 422 | 353 | } | 423 | 665 | } else { | 424 | 269 | if ( useIEEEFunction == true ) { | 425 | 268 | InputCorrect<float, -1, 1>::Correct(inDataL, inDataSize * 2); | 426 | | | 427 | 268 | Debug ? printf("{\n") : 0; | 428 | | | 429 | 268 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize * 2).c_str()) : 0; | 430 | | | 431 | 268 | Debug ? printf("%s\n", DebugDefineArray<float>::Str("inDataL", "float", inDataL, inDataSize * 2, true).c_str()) : 0; | 432 | | | 433 | 268 | Debug ? | 434 | 0 | printf("\tlame_encode_buffer_interleaved_ieee_float(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") | 435 | 268 | : 0; | 436 | | | 437 | 268 | const int ret = lame_encode_buffer_interleaved_ieee_float(flags, inDataL, inDataSize, outBuffer, outBufferSize); | 438 | | | 439 | 268 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 440 | | | 441 | 268 | Debug ? printf("}\n") : 0; | 442 | | | 443 | 268 | return ret; | 444 | 268 | } else { | 445 | | /* No function for interleaved float */ | 446 | 1 | return -1; | 447 | 1 | } | 448 | 269 | } | 449 | 934 | } |
Unexecuted instantiation: EncoderCore<float, true>::EncodeSingle<float, true>::encode(lame_global_struct*, float*, float*, unsigned long, unsigned char*, unsigned long, bool, bool) |
450 | | }; |
451 | | |
452 | | template<bool Debug_> struct EncodeSingle<double, Debug_> { |
453 | | int static encode( |
454 | | lame_global_flags* flags, |
455 | | double* inDataL, |
456 | | double* inDataR, |
457 | | const size_t inDataSize, |
458 | | uint8_t* outBuffer, |
459 | | const size_t outBufferSize, |
460 | | bool useInterleavingFunction, |
461 | 458 | bool useIEEEFunction) { |
462 | | |
463 | 458 | if ( useInterleavingFunction == false ) { |
464 | 354 | if ( useIEEEFunction == false ) { |
465 | | /* No non-IEEE function for interleaved double */ |
466 | 3 | return -1; |
467 | 351 | } else { |
468 | 351 | InputCorrect<double, -1, 1>::Correct(inDataL, inDataSize); |
469 | 351 | InputCorrect<double, -1, 1>::Correct(inDataR, inDataSize); |
470 | | |
471 | 351 | Debug ? printf("{\n") : 0; |
472 | | |
473 | 351 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
474 | | |
475 | 351 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataL", "double", inDataL, inDataSize, true).c_str()) : 0; |
476 | 351 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataR", "double", inDataR, inDataSize, true).c_str()) : 0; |
477 | | |
478 | 351 | Debug ? |
479 | 0 | printf("\tlame_encode_buffer_ieee_double(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") |
480 | 351 | : 0; |
481 | | |
482 | 351 | const int ret = lame_encode_buffer_ieee_double(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); |
483 | | |
484 | 351 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
485 | | |
486 | 351 | Debug ? printf("}\n") : 0; |
487 | | |
488 | 351 | return ret; |
489 | 351 | } |
490 | 354 | } else { |
491 | 104 | if ( useIEEEFunction == false ) { |
492 | 103 | InputCorrect<double, -1, 1>::Correct(inDataL, inDataSize * 2); |
493 | | |
494 | 103 | Debug ? printf("{\n") : 0; |
495 | | |
496 | 103 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; |
497 | | |
498 | 103 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataL", "double", inDataL, inDataSize * 2, true).c_str()) : 0; |
499 | | |
500 | 103 | Debug ? |
501 | 0 | printf("lame_encode_buffer_interleaved_ieee_double(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") |
502 | 103 | : 0; |
503 | | |
504 | 103 | const int ret = lame_encode_buffer_interleaved_ieee_double(flags, inDataL, inDataSize, outBuffer, outBufferSize); |
505 | | |
506 | | |
507 | 103 | Debug ? printf("\t// (returns %d)\n", ret) : 0; |
508 | | |
509 | 103 | Debug ? printf("}\n") : 0; |
510 | | |
511 | 103 | return ret; |
512 | 103 | } else { |
513 | | /* No non-IEEE function for double */ |
514 | 1 | return -1; |
515 | 1 | } |
516 | 104 | } |
517 | 458 | } EncoderCore<double, false>::EncodeSingle<double, false>::encode(lame_global_struct*, double*, double*, unsigned long, unsigned char*, unsigned long, bool, bool) Line | Count | Source | 461 | 458 | bool useIEEEFunction) { | 462 | | | 463 | 458 | if ( useInterleavingFunction == false ) { | 464 | 354 | if ( useIEEEFunction == false ) { | 465 | | /* No non-IEEE function for interleaved double */ | 466 | 3 | return -1; | 467 | 351 | } else { | 468 | 351 | InputCorrect<double, -1, 1>::Correct(inDataL, inDataSize); | 469 | 351 | InputCorrect<double, -1, 1>::Correct(inDataR, inDataSize); | 470 | | | 471 | 351 | Debug ? printf("{\n") : 0; | 472 | | | 473 | 351 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 474 | | | 475 | 351 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataL", "double", inDataL, inDataSize, true).c_str()) : 0; | 476 | 351 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataR", "double", inDataR, inDataSize, true).c_str()) : 0; | 477 | | | 478 | 351 | Debug ? | 479 | 0 | printf("\tlame_encode_buffer_ieee_double(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize);\n") | 480 | 351 | : 0; | 481 | | | 482 | 351 | const int ret = lame_encode_buffer_ieee_double(flags, inDataL, inDataR, inDataSize, outBuffer, outBufferSize); | 483 | | | 484 | 351 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 485 | | | 486 | 351 | Debug ? printf("}\n") : 0; | 487 | | | 488 | 351 | return ret; | 489 | 351 | } | 490 | 354 | } else { | 491 | 104 | if ( useIEEEFunction == false ) { | 492 | 103 | InputCorrect<double, -1, 1>::Correct(inDataL, inDataSize * 2); | 493 | | | 494 | 103 | Debug ? printf("{\n") : 0; | 495 | | | 496 | 103 | Debug ? printf("\t%s\n", debug_define_size_t("inDataSize", inDataSize).c_str()) : 0; | 497 | | | 498 | 103 | Debug ? printf("%s\n", DebugDefineArray<double>::Str("inDataL", "double", inDataL, inDataSize * 2, true).c_str()) : 0; | 499 | | | 500 | 103 | Debug ? | 501 | 0 | printf("lame_encode_buffer_interleaved_ieee_double(flags, inDataL, inDataSize, outBuffer, outBufferSize);\n") | 502 | 103 | : 0; | 503 | | | 504 | 103 | const int ret = lame_encode_buffer_interleaved_ieee_double(flags, inDataL, inDataSize, outBuffer, outBufferSize); | 505 | | | 506 | | | 507 | 103 | Debug ? printf("\t// (returns %d)\n", ret) : 0; | 508 | | | 509 | 103 | Debug ? printf("}\n") : 0; | 510 | | | 511 | 103 | return ret; | 512 | 103 | } else { | 513 | | /* No non-IEEE function for double */ | 514 | 1 | return -1; | 515 | 1 | } | 516 | 104 | } | 517 | 458 | } |
Unexecuted instantiation: EncoderCore<double, true>::EncodeSingle<double, true>::encode(lame_global_struct*, double*, double*, unsigned long, unsigned char*, unsigned long, bool, bool) |
518 | | }; |
519 | | |
520 | 9.68k | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { |
521 | 9.68k | if ( useInterleavingFunction && mono ) { |
522 | 5 | return -1; |
523 | 5 | } |
524 | | |
525 | 9.68k | if ( mono == true ) { |
526 | 1.57k | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); |
527 | 8.10k | } else if ( useInterleavingFunction ) { |
528 | 2.97k | const size_t numSamples = inData.size() / 2; |
529 | | |
530 | 2.97k | std::vector<T> inDataCopy; |
531 | 2.97k | inDataCopy.resize(numSamples * 2); |
532 | | |
533 | 2.97k | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); |
534 | | |
535 | 2.97k | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); |
536 | 5.13k | } else { |
537 | 5.13k | size_t numSamples = inData.size(); |
538 | | |
539 | | /* Round to a multiple of 2 */ |
540 | 5.13k | if ( numSamples % 2 ) { |
541 | 1.95k | numSamples--; |
542 | 1.95k | } |
543 | | |
544 | | /* To samples per channel */ |
545 | 5.13k | numSamples /= 2; |
546 | | |
547 | | /* Left, right channels */ |
548 | 5.13k | std::vector<T> inDataL, inDataR; |
549 | 5.13k | inDataL.resize(numSamples); |
550 | 5.13k | inDataR.resize(numSamples); |
551 | | |
552 | | /* Split inData evenly between inDataL and inDataR */ |
553 | 5.13k | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); |
554 | 5.13k | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); |
555 | | |
556 | 5.13k | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); |
557 | 5.13k | } |
558 | 9.68k | } EncoderCore<short, false>::encode(std::__1::vector<short, std::__1::allocator<short> >&, unsigned char*, unsigned long, bool) Line | Count | Source | 520 | 7.17k | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { | 521 | 7.17k | if ( useInterleavingFunction && mono ) { | 522 | 1 | return -1; | 523 | 1 | } | 524 | | | 525 | 7.17k | if ( mono == true ) { | 526 | 1.01k | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 527 | 6.16k | } else if ( useInterleavingFunction ) { | 528 | 2.45k | const size_t numSamples = inData.size() / 2; | 529 | | | 530 | 2.45k | std::vector<T> inDataCopy; | 531 | 2.45k | inDataCopy.resize(numSamples * 2); | 532 | | | 533 | 2.45k | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); | 534 | | | 535 | 2.45k | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 536 | 3.70k | } else { | 537 | 3.70k | size_t numSamples = inData.size(); | 538 | | | 539 | | /* Round to a multiple of 2 */ | 540 | 3.70k | if ( numSamples % 2 ) { | 541 | 1.54k | numSamples--; | 542 | 1.54k | } | 543 | | | 544 | | /* To samples per channel */ | 545 | 3.70k | numSamples /= 2; | 546 | | | 547 | | /* Left, right channels */ | 548 | 3.70k | std::vector<T> inDataL, inDataR; | 549 | 3.70k | inDataL.resize(numSamples); | 550 | 3.70k | inDataR.resize(numSamples); | 551 | | | 552 | | /* Split inData evenly between inDataL and inDataR */ | 553 | 3.70k | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); | 554 | 3.70k | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); | 555 | | | 556 | 3.70k | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 557 | 3.70k | } | 558 | 7.17k | } |
EncoderCore<int, false>::encode(std::__1::vector<int, std::__1::allocator<int> >&, unsigned char*, unsigned long, bool) Line | Count | Source | 520 | 413 | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { | 521 | 413 | if ( useInterleavingFunction && mono ) { | 522 | 1 | return -1; | 523 | 1 | } | 524 | | | 525 | 412 | if ( mono == true ) { | 526 | 111 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 527 | 301 | } else if ( useInterleavingFunction ) { | 528 | 120 | const size_t numSamples = inData.size() / 2; | 529 | | | 530 | 120 | std::vector<T> inDataCopy; | 531 | 120 | inDataCopy.resize(numSamples * 2); | 532 | | | 533 | 120 | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); | 534 | | | 535 | 120 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 536 | 181 | } else { | 537 | 181 | size_t numSamples = inData.size(); | 538 | | | 539 | | /* Round to a multiple of 2 */ | 540 | 181 | if ( numSamples % 2 ) { | 541 | 45 | numSamples--; | 542 | 45 | } | 543 | | | 544 | | /* To samples per channel */ | 545 | 181 | numSamples /= 2; | 546 | | | 547 | | /* Left, right channels */ | 548 | 181 | std::vector<T> inDataL, inDataR; | 549 | 181 | inDataL.resize(numSamples); | 550 | 181 | inDataR.resize(numSamples); | 551 | | | 552 | | /* Split inData evenly between inDataL and inDataR */ | 553 | 181 | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); | 554 | 181 | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); | 555 | | | 556 | 181 | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 557 | 181 | } | 558 | 412 | } |
EncoderCore<long, false>::encode(std::__1::vector<long, std::__1::allocator<long> >&, unsigned char*, unsigned long, bool) Line | Count | Source | 520 | 703 | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { | 521 | 703 | if ( useInterleavingFunction && mono ) { | 522 | 1 | return -1; | 523 | 1 | } | 524 | | | 525 | 702 | if ( mono == true ) { | 526 | 195 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 527 | 507 | } else if ( useInterleavingFunction ) { | 528 | 23 | const size_t numSamples = inData.size() / 2; | 529 | | | 530 | 23 | std::vector<T> inDataCopy; | 531 | 23 | inDataCopy.resize(numSamples * 2); | 532 | | | 533 | 23 | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); | 534 | | | 535 | 23 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 536 | 484 | } else { | 537 | 484 | size_t numSamples = inData.size(); | 538 | | | 539 | | /* Round to a multiple of 2 */ | 540 | 484 | if ( numSamples % 2 ) { | 541 | 144 | numSamples--; | 542 | 144 | } | 543 | | | 544 | | /* To samples per channel */ | 545 | 484 | numSamples /= 2; | 546 | | | 547 | | /* Left, right channels */ | 548 | 484 | std::vector<T> inDataL, inDataR; | 549 | 484 | inDataL.resize(numSamples); | 550 | 484 | inDataR.resize(numSamples); | 551 | | | 552 | | /* Split inData evenly between inDataL and inDataR */ | 553 | 484 | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); | 554 | 484 | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); | 555 | | | 556 | 484 | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 557 | 484 | } | 558 | 702 | } |
EncoderCore<float, false>::encode(std::__1::vector<float, std::__1::allocator<float> >&, unsigned char*, unsigned long, bool) Line | Count | Source | 520 | 935 | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { | 521 | 935 | if ( useInterleavingFunction && mono ) { | 522 | 1 | return -1; | 523 | 1 | } | 524 | | | 525 | 934 | if ( mono == true ) { | 526 | 135 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 527 | 799 | } else if ( useInterleavingFunction ) { | 528 | 269 | const size_t numSamples = inData.size() / 2; | 529 | | | 530 | 269 | std::vector<T> inDataCopy; | 531 | 269 | inDataCopy.resize(numSamples * 2); | 532 | | | 533 | 269 | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); | 534 | | | 535 | 269 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 536 | 530 | } else { | 537 | 530 | size_t numSamples = inData.size(); | 538 | | | 539 | | /* Round to a multiple of 2 */ | 540 | 530 | if ( numSamples % 2 ) { | 541 | 116 | numSamples--; | 542 | 116 | } | 543 | | | 544 | | /* To samples per channel */ | 545 | 530 | numSamples /= 2; | 546 | | | 547 | | /* Left, right channels */ | 548 | 530 | std::vector<T> inDataL, inDataR; | 549 | 530 | inDataL.resize(numSamples); | 550 | 530 | inDataR.resize(numSamples); | 551 | | | 552 | | /* Split inData evenly between inDataL and inDataR */ | 553 | 530 | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); | 554 | 530 | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); | 555 | | | 556 | 530 | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 557 | 530 | } | 558 | 934 | } |
EncoderCore<double, false>::encode(std::__1::vector<double, std::__1::allocator<double> >&, unsigned char*, unsigned long, bool) Line | Count | Source | 520 | 459 | int encode(std::vector<T>& inData, uint8_t* outBuffer, const size_t outBufferSize, const bool mono) { | 521 | 459 | if ( useInterleavingFunction && mono ) { | 522 | 1 | return -1; | 523 | 1 | } | 524 | | | 525 | 458 | if ( mono == true ) { | 526 | 123 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, inData.size() / 2, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 527 | 335 | } else if ( useInterleavingFunction ) { | 528 | 104 | const size_t numSamples = inData.size() / 2; | 529 | | | 530 | 104 | std::vector<T> inDataCopy; | 531 | 104 | inDataCopy.resize(numSamples * 2); | 532 | | | 533 | 104 | memcpy(inDataCopy.data(), inData.data(), numSamples * 2 * sizeof(T)); | 534 | | | 535 | 104 | return EncodeSingle<T, Debug>::encode(flags, inData.data(), nullptr, numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 536 | 231 | } else { | 537 | 231 | size_t numSamples = inData.size(); | 538 | | | 539 | | /* Round to a multiple of 2 */ | 540 | 231 | if ( numSamples % 2 ) { | 541 | 105 | numSamples--; | 542 | 105 | } | 543 | | | 544 | | /* To samples per channel */ | 545 | 231 | numSamples /= 2; | 546 | | | 547 | | /* Left, right channels */ | 548 | 231 | std::vector<T> inDataL, inDataR; | 549 | 231 | inDataL.resize(numSamples); | 550 | 231 | inDataR.resize(numSamples); | 551 | | | 552 | | /* Split inData evenly between inDataL and inDataR */ | 553 | 231 | memcpy(inDataL.data(), inData.data(), numSamples * sizeof(T)); | 554 | 231 | memcpy(inDataR.data(), inData.data() + numSamples, numSamples * sizeof(T)); | 555 | | | 556 | 231 | return EncodeSingle<T, Debug>::encode(flags, inDataL.data(), inDataR.data(), numSamples, outBuffer, outBufferSize, useInterleavingFunction, useIEEEFunction); | 557 | 231 | } | 558 | 458 | } |
Unexecuted instantiation: EncoderCore<short, true>::encode(std::__1::vector<short, std::__1::allocator<short> >&, unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<int, true>::encode(std::__1::vector<int, std::__1::allocator<int> >&, unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<long, true>::encode(std::__1::vector<long, std::__1::allocator<long> >&, unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<float, true>::encode(std::__1::vector<float, std::__1::allocator<float> >&, unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<double, true>::encode(std::__1::vector<double, std::__1::allocator<double> >&, unsigned char*, unsigned long, bool) |
559 | | |
560 | 9.58k | int flush(uint8_t* outBuffer, const size_t outBufferSize) { |
561 | 9.58k | if ( ds.Get<bool>() ) { |
562 | | /* No flush */ |
563 | 1.16k | return 0; |
564 | 1.16k | } |
565 | | |
566 | 8.42k | if ( ds.Get<bool>() ) { |
567 | 6.43k | Debug ? |
568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") |
569 | 6.43k | : 0; |
570 | | |
571 | 6.43k | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); |
572 | | |
573 | 6.43k | Debug ? printf("// (returns %d)\n", ret) : 0; |
574 | | |
575 | 6.43k | if ( ret > static_cast<int>(outBufferSize) ) { |
576 | | /* Crashes |
577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); |
578 | | |
579 | | abort(); |
580 | | */ |
581 | 0 | } |
582 | | |
583 | 6.43k | return ret; |
584 | 6.43k | } else { |
585 | | #if 0 |
586 | | /* XXX disabled because it prints: |
587 | | * "strange error flushing buffer ..." |
588 | | */ |
589 | | Debug ? |
590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") |
591 | | : 0; |
592 | | |
593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); |
594 | | |
595 | | Debug ? printf("// (returns %d)\n", ret) : 0; |
596 | | |
597 | | return ret; |
598 | | #else |
599 | 1.99k | return 0; |
600 | 1.99k | #endif |
601 | 1.99k | } |
602 | 8.42k | } EncoderCore<short, false>::flush(unsigned char*, unsigned long) Line | Count | Source | 560 | 7.14k | int flush(uint8_t* outBuffer, const size_t outBufferSize) { | 561 | 7.14k | if ( ds.Get<bool>() ) { | 562 | | /* No flush */ | 563 | 653 | return 0; | 564 | 653 | } | 565 | | | 566 | 6.49k | if ( ds.Get<bool>() ) { | 567 | 5.60k | Debug ? | 568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") | 569 | 5.60k | : 0; | 570 | | | 571 | 5.60k | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); | 572 | | | 573 | 5.60k | Debug ? printf("// (returns %d)\n", ret) : 0; | 574 | | | 575 | 5.60k | if ( ret > static_cast<int>(outBufferSize) ) { | 576 | | /* Crashes | 577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); | 578 | | | 579 | | abort(); | 580 | | */ | 581 | 0 | } | 582 | | | 583 | 5.60k | return ret; | 584 | 5.60k | } else { | 585 | | #if 0 | 586 | | /* XXX disabled because it prints: | 587 | | * "strange error flushing buffer ..." | 588 | | */ | 589 | | Debug ? | 590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") | 591 | | : 0; | 592 | | | 593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); | 594 | | | 595 | | Debug ? printf("// (returns %d)\n", ret) : 0; | 596 | | | 597 | | return ret; | 598 | | #else | 599 | 885 | return 0; | 600 | 885 | #endif | 601 | 885 | } | 602 | 6.49k | } |
EncoderCore<int, false>::flush(unsigned char*, unsigned long) Line | Count | Source | 560 | 405 | int flush(uint8_t* outBuffer, const size_t outBufferSize) { | 561 | 405 | if ( ds.Get<bool>() ) { | 562 | | /* No flush */ | 563 | 125 | return 0; | 564 | 125 | } | 565 | | | 566 | 280 | if ( ds.Get<bool>() ) { | 567 | 138 | Debug ? | 568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") | 569 | 138 | : 0; | 570 | | | 571 | 138 | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); | 572 | | | 573 | 138 | Debug ? printf("// (returns %d)\n", ret) : 0; | 574 | | | 575 | 138 | if ( ret > static_cast<int>(outBufferSize) ) { | 576 | | /* Crashes | 577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); | 578 | | | 579 | | abort(); | 580 | | */ | 581 | 0 | } | 582 | | | 583 | 138 | return ret; | 584 | 142 | } else { | 585 | | #if 0 | 586 | | /* XXX disabled because it prints: | 587 | | * "strange error flushing buffer ..." | 588 | | */ | 589 | | Debug ? | 590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") | 591 | | : 0; | 592 | | | 593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); | 594 | | | 595 | | Debug ? printf("// (returns %d)\n", ret) : 0; | 596 | | | 597 | | return ret; | 598 | | #else | 599 | 142 | return 0; | 600 | 142 | #endif | 601 | 142 | } | 602 | 280 | } |
EncoderCore<long, false>::flush(unsigned char*, unsigned long) Line | Count | Source | 560 | 671 | int flush(uint8_t* outBuffer, const size_t outBufferSize) { | 561 | 671 | if ( ds.Get<bool>() ) { | 562 | | /* No flush */ | 563 | 97 | return 0; | 564 | 97 | } | 565 | | | 566 | 574 | if ( ds.Get<bool>() ) { | 567 | 149 | Debug ? | 568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") | 569 | 149 | : 0; | 570 | | | 571 | 149 | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); | 572 | | | 573 | 149 | Debug ? printf("// (returns %d)\n", ret) : 0; | 574 | | | 575 | 149 | if ( ret > static_cast<int>(outBufferSize) ) { | 576 | | /* Crashes | 577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); | 578 | | | 579 | | abort(); | 580 | | */ | 581 | 0 | } | 582 | | | 583 | 149 | return ret; | 584 | 425 | } else { | 585 | | #if 0 | 586 | | /* XXX disabled because it prints: | 587 | | * "strange error flushing buffer ..." | 588 | | */ | 589 | | Debug ? | 590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") | 591 | | : 0; | 592 | | | 593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); | 594 | | | 595 | | Debug ? printf("// (returns %d)\n", ret) : 0; | 596 | | | 597 | | return ret; | 598 | | #else | 599 | 425 | return 0; | 600 | 425 | #endif | 601 | 425 | } | 602 | 574 | } |
EncoderCore<float, false>::flush(unsigned char*, unsigned long) Line | Count | Source | 560 | 924 | int flush(uint8_t* outBuffer, const size_t outBufferSize) { | 561 | 924 | if ( ds.Get<bool>() ) { | 562 | | /* No flush */ | 563 | 192 | return 0; | 564 | 192 | } | 565 | | | 566 | 732 | if ( ds.Get<bool>() ) { | 567 | 429 | Debug ? | 568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") | 569 | 429 | : 0; | 570 | | | 571 | 429 | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); | 572 | | | 573 | 429 | Debug ? printf("// (returns %d)\n", ret) : 0; | 574 | | | 575 | 429 | if ( ret > static_cast<int>(outBufferSize) ) { | 576 | | /* Crashes | 577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); | 578 | | | 579 | | abort(); | 580 | | */ | 581 | 0 | } | 582 | | | 583 | 429 | return ret; | 584 | 429 | } else { | 585 | | #if 0 | 586 | | /* XXX disabled because it prints: | 587 | | * "strange error flushing buffer ..." | 588 | | */ | 589 | | Debug ? | 590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") | 591 | | : 0; | 592 | | | 593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); | 594 | | | 595 | | Debug ? printf("// (returns %d)\n", ret) : 0; | 596 | | | 597 | | return ret; | 598 | | #else | 599 | 303 | return 0; | 600 | 303 | #endif | 601 | 303 | } | 602 | 732 | } |
EncoderCore<double, false>::flush(unsigned char*, unsigned long) Line | Count | Source | 560 | 445 | int flush(uint8_t* outBuffer, const size_t outBufferSize) { | 561 | 445 | if ( ds.Get<bool>() ) { | 562 | | /* No flush */ | 563 | 100 | return 0; | 564 | 100 | } | 565 | | | 566 | 345 | if ( ds.Get<bool>() ) { | 567 | 109 | Debug ? | 568 | 0 | printf("lame_encode_flush(flags, outBuffer, outBufferSize);\n") | 569 | 109 | : 0; | 570 | | | 571 | 109 | const int ret = lame_encode_flush(flags, outBuffer, outBufferSize); | 572 | | | 573 | 109 | Debug ? printf("// (returns %d)\n", ret) : 0; | 574 | | | 575 | 109 | if ( ret > static_cast<int>(outBufferSize) ) { | 576 | | /* Crashes | 577 | | printf("lame_encode_flush reported more output bytes (%zu) than the buffer can hold (%zu)\n", static_cast<size_t>(ret), outBufferSize); | 578 | | | 579 | | abort(); | 580 | | */ | 581 | 0 | } | 582 | | | 583 | 109 | return ret; | 584 | 236 | } else { | 585 | | #if 0 | 586 | | /* XXX disabled because it prints: | 587 | | * "strange error flushing buffer ..." | 588 | | */ | 589 | | Debug ? | 590 | | printf("lame_encode_flush_nogap(flags, outBuffer, outBufferSize);\n") | 591 | | : 0; | 592 | | | 593 | | const int ret = lame_encode_flush_nogap(flags, outBuffer, outBufferSize); | 594 | | | 595 | | Debug ? printf("// (returns %d)\n", ret) : 0; | 596 | | | 597 | | return ret; | 598 | | #else | 599 | 236 | return 0; | 600 | 236 | #endif | 601 | 236 | } | 602 | 345 | } |
Unexecuted instantiation: EncoderCore<short, true>::flush(unsigned char*, unsigned long) Unexecuted instantiation: EncoderCore<int, true>::flush(unsigned char*, unsigned long) Unexecuted instantiation: EncoderCore<long, true>::flush(unsigned char*, unsigned long) Unexecuted instantiation: EncoderCore<float, true>::flush(unsigned char*, unsigned long) Unexecuted instantiation: EncoderCore<double, true>::flush(unsigned char*, unsigned long) |
603 | | public: |
604 | | EncoderCore(Datasource& ds, lame_global_flags* flags) : |
605 | | EncoderCoreBase(), |
606 | | ds(ds), |
607 | | flags(flags), |
608 | | it(inDataV.end()), |
609 | | useInterleavingFunction( ds.Get<bool>() ), |
610 | | useIEEEFunction( ds.Get<bool>() ) |
611 | 7.21k | { |
612 | 7.21k | getInputData(); |
613 | 7.21k | } EncoderCore<short, false>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Line | Count | Source | 611 | 4.25k | { | 612 | 4.25k | getInputData(); | 613 | 4.25k | } |
EncoderCore<int, false>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Line | Count | Source | 611 | 599 | { | 612 | 599 | getInputData(); | 613 | 599 | } |
EncoderCore<long, false>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Line | Count | Source | 611 | 914 | { | 612 | 914 | getInputData(); | 613 | 914 | } |
EncoderCore<float, false>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Line | Count | Source | 611 | 840 | { | 612 | 840 | getInputData(); | 613 | 840 | } |
EncoderCore<double, false>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Line | Count | Source | 611 | 610 | { | 612 | 610 | getInputData(); | 613 | 610 | } |
Unexecuted instantiation: EncoderCore<short, true>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Unexecuted instantiation: EncoderCore<int, true>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Unexecuted instantiation: EncoderCore<long, true>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Unexecuted instantiation: EncoderCore<float, true>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) Unexecuted instantiation: EncoderCore<double, true>::EncoderCore(fuzzing::datasource::Datasource&, lame_global_struct*) |
614 | | |
615 | 11.6k | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { |
616 | 11.6k | if ( it == inDataV.end() ) { |
617 | 1.98k | return false; |
618 | 1.98k | } |
619 | | |
620 | 9.68k | auto& inData = *it; |
621 | 9.68k | it++; |
622 | | |
623 | | #ifdef MSAN |
624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, |
625 | | * this can be detected. |
626 | | */ |
627 | | __msan_allocated_memory(outBuffer, outBufferSize); |
628 | | #endif |
629 | | |
630 | 9.68k | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); |
631 | | |
632 | 9.68k | if ( encodeRet < 0 ) { |
633 | 98 | return false; |
634 | 98 | } |
635 | | |
636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ |
637 | 9.58k | if ( encodeRet > static_cast<int>(outBufferSize) ) { |
638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); |
639 | |
|
640 | 0 | abort(); |
641 | 0 | } |
642 | | |
643 | | #ifdef MSAN |
644 | | /* Check for uninitialized data in the output buffer */ |
645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); |
646 | | |
647 | | /* Poison it again */ |
648 | | __msan_allocated_memory(outBuffer, outBufferSize); |
649 | | #endif |
650 | | |
651 | 9.58k | const int flushRet = flush(outBuffer, outBufferSize); |
652 | | |
653 | 9.58k | if ( flushRet < 0 ) { |
654 | 400 | return false; |
655 | 400 | } |
656 | | |
657 | 9.18k | fuzzing::memory::memory_test_msan(outBuffer, flushRet); |
658 | | |
659 | 9.18k | if ( encodeRet == 0 ) { |
660 | 1.63k | return false; |
661 | 1.63k | } |
662 | | |
663 | 7.55k | return true; |
664 | 9.18k | } EncoderCore<short, false>::Run(unsigned char*, unsigned long, bool) Line | Count | Source | 615 | 8.65k | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { | 616 | 8.65k | if ( it == inDataV.end() ) { | 617 | 1.48k | return false; | 618 | 1.48k | } | 619 | | | 620 | 7.17k | auto& inData = *it; | 621 | 7.17k | it++; | 622 | | | 623 | | #ifdef MSAN | 624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, | 625 | | * this can be detected. | 626 | | */ | 627 | | __msan_allocated_memory(outBuffer, outBufferSize); | 628 | | #endif | 629 | | | 630 | 7.17k | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); | 631 | | | 632 | 7.17k | if ( encodeRet < 0 ) { | 633 | 33 | return false; | 634 | 33 | } | 635 | | | 636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ | 637 | 7.14k | if ( encodeRet > static_cast<int>(outBufferSize) ) { | 638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); | 639 | |
| 640 | 0 | abort(); | 641 | 0 | } | 642 | | | 643 | | #ifdef MSAN | 644 | | /* Check for uninitialized data in the output buffer */ | 645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); | 646 | | | 647 | | /* Poison it again */ | 648 | | __msan_allocated_memory(outBuffer, outBufferSize); | 649 | | #endif | 650 | | | 651 | 7.14k | const int flushRet = flush(outBuffer, outBufferSize); | 652 | | | 653 | 7.14k | if ( flushRet < 0 ) { | 654 | 307 | return false; | 655 | 307 | } | 656 | | | 657 | 6.83k | fuzzing::memory::memory_test_msan(outBuffer, flushRet); | 658 | | | 659 | 6.83k | if ( encodeRet == 0 ) { | 660 | 1.29k | return false; | 661 | 1.29k | } | 662 | | | 663 | 5.54k | return true; | 664 | 6.83k | } |
EncoderCore<int, false>::Run(unsigned char*, unsigned long, bool) Line | Count | Source | 615 | 547 | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { | 616 | 547 | if ( it == inDataV.end() ) { | 617 | 134 | return false; | 618 | 134 | } | 619 | | | 620 | 413 | auto& inData = *it; | 621 | 413 | it++; | 622 | | | 623 | | #ifdef MSAN | 624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, | 625 | | * this can be detected. | 626 | | */ | 627 | | __msan_allocated_memory(outBuffer, outBufferSize); | 628 | | #endif | 629 | | | 630 | 413 | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); | 631 | | | 632 | 413 | if ( encodeRet < 0 ) { | 633 | 8 | return false; | 634 | 8 | } | 635 | | | 636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ | 637 | 405 | if ( encodeRet > static_cast<int>(outBufferSize) ) { | 638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); | 639 | |
| 640 | 0 | abort(); | 641 | 0 | } | 642 | | | 643 | | #ifdef MSAN | 644 | | /* Check for uninitialized data in the output buffer */ | 645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); | 646 | | | 647 | | /* Poison it again */ | 648 | | __msan_allocated_memory(outBuffer, outBufferSize); | 649 | | #endif | 650 | | | 651 | 405 | const int flushRet = flush(outBuffer, outBufferSize); | 652 | | | 653 | 405 | if ( flushRet < 0 ) { | 654 | 20 | return false; | 655 | 20 | } | 656 | | | 657 | 385 | fuzzing::memory::memory_test_msan(outBuffer, flushRet); | 658 | | | 659 | 385 | if ( encodeRet == 0 ) { | 660 | 52 | return false; | 661 | 52 | } | 662 | | | 663 | 333 | return true; | 664 | 385 | } |
EncoderCore<long, false>::Run(unsigned char*, unsigned long, bool) Line | Count | Source | 615 | 798 | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { | 616 | 798 | if ( it == inDataV.end() ) { | 617 | 95 | return false; | 618 | 95 | } | 619 | | | 620 | 703 | auto& inData = *it; | 621 | 703 | it++; | 622 | | | 623 | | #ifdef MSAN | 624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, | 625 | | * this can be detected. | 626 | | */ | 627 | | __msan_allocated_memory(outBuffer, outBufferSize); | 628 | | #endif | 629 | | | 630 | 703 | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); | 631 | | | 632 | 703 | if ( encodeRet < 0 ) { | 633 | 32 | return false; | 634 | 32 | } | 635 | | | 636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ | 637 | 671 | if ( encodeRet > static_cast<int>(outBufferSize) ) { | 638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); | 639 | |
| 640 | 0 | abort(); | 641 | 0 | } | 642 | | | 643 | | #ifdef MSAN | 644 | | /* Check for uninitialized data in the output buffer */ | 645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); | 646 | | | 647 | | /* Poison it again */ | 648 | | __msan_allocated_memory(outBuffer, outBufferSize); | 649 | | #endif | 650 | | | 651 | 671 | const int flushRet = flush(outBuffer, outBufferSize); | 652 | | | 653 | 671 | if ( flushRet < 0 ) { | 654 | 15 | return false; | 655 | 15 | } | 656 | | | 657 | 656 | fuzzing::memory::memory_test_msan(outBuffer, flushRet); | 658 | | | 659 | 656 | if ( encodeRet == 0 ) { | 660 | 79 | return false; | 661 | 79 | } | 662 | | | 663 | 577 | return true; | 664 | 656 | } |
EncoderCore<float, false>::Run(unsigned char*, unsigned long, bool) Line | Count | Source | 615 | 1.12k | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { | 616 | 1.12k | if ( it == inDataV.end() ) { | 617 | 191 | return false; | 618 | 191 | } | 619 | | | 620 | 935 | auto& inData = *it; | 621 | 935 | it++; | 622 | | | 623 | | #ifdef MSAN | 624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, | 625 | | * this can be detected. | 626 | | */ | 627 | | __msan_allocated_memory(outBuffer, outBufferSize); | 628 | | #endif | 629 | | | 630 | 935 | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); | 631 | | | 632 | 935 | if ( encodeRet < 0 ) { | 633 | 11 | return false; | 634 | 11 | } | 635 | | | 636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ | 637 | 924 | if ( encodeRet > static_cast<int>(outBufferSize) ) { | 638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); | 639 | |
| 640 | 0 | abort(); | 641 | 0 | } | 642 | | | 643 | | #ifdef MSAN | 644 | | /* Check for uninitialized data in the output buffer */ | 645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); | 646 | | | 647 | | /* Poison it again */ | 648 | | __msan_allocated_memory(outBuffer, outBufferSize); | 649 | | #endif | 650 | | | 651 | 924 | const int flushRet = flush(outBuffer, outBufferSize); | 652 | | | 653 | 924 | if ( flushRet < 0 ) { | 654 | 51 | return false; | 655 | 51 | } | 656 | | | 657 | 873 | fuzzing::memory::memory_test_msan(outBuffer, flushRet); | 658 | | | 659 | 873 | if ( encodeRet == 0 ) { | 660 | 155 | return false; | 661 | 155 | } | 662 | | | 663 | 718 | return true; | 664 | 873 | } |
EncoderCore<double, false>::Run(unsigned char*, unsigned long, bool) Line | Count | Source | 615 | 538 | bool Run(uint8_t* outBuffer, const size_t outBufferSize, const bool mono) override { | 616 | 538 | if ( it == inDataV.end() ) { | 617 | 79 | return false; | 618 | 79 | } | 619 | | | 620 | 459 | auto& inData = *it; | 621 | 459 | it++; | 622 | | | 623 | | #ifdef MSAN | 624 | | /* Poison the outbuffer so if encode() puts uninitialized memory in it, | 625 | | * this can be detected. | 626 | | */ | 627 | | __msan_allocated_memory(outBuffer, outBufferSize); | 628 | | #endif | 629 | | | 630 | 459 | const int encodeRet = encode(inData, outBuffer, outBufferSize, mono); | 631 | | | 632 | 459 | if ( encodeRet < 0 ) { | 633 | 14 | return false; | 634 | 14 | } | 635 | | | 636 | | /* static_cast is safe because outBufferSize is never anywhere near 2**31 */ | 637 | 445 | if ( encodeRet > static_cast<int>(outBufferSize) ) { | 638 | 0 | printf("encode reported more output bytes than the buffer can hold\n"); | 639 | |
| 640 | 0 | abort(); | 641 | 0 | } | 642 | | | 643 | | #ifdef MSAN | 644 | | /* Check for uninitialized data in the output buffer */ | 645 | | fuzzing::memory::memory_test_msan(outBuffer, encodeRet); | 646 | | | 647 | | /* Poison it again */ | 648 | | __msan_allocated_memory(outBuffer, outBufferSize); | 649 | | #endif | 650 | | | 651 | 445 | const int flushRet = flush(outBuffer, outBufferSize); | 652 | | | 653 | 445 | if ( flushRet < 0 ) { | 654 | 7 | return false; | 655 | 7 | } | 656 | | | 657 | 438 | fuzzing::memory::memory_test_msan(outBuffer, flushRet); | 658 | | | 659 | 438 | if ( encodeRet == 0 ) { | 660 | 53 | return false; | 661 | 53 | } | 662 | | | 663 | 385 | return true; | 664 | 438 | } |
Unexecuted instantiation: EncoderCore<short, true>::Run(unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<int, true>::Run(unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<long, true>::Run(unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<float, true>::Run(unsigned char*, unsigned long, bool) Unexecuted instantiation: EncoderCore<double, true>::Run(unsigned char*, unsigned long, bool) |
665 | | }; |
666 | | |
667 | | /* In the interest of speed, let Debug be a template parameter, |
668 | | * so that in non-debug mode, all debug checks will be optimized away. |
669 | | */ |
670 | | template <bool Debug> |
671 | | class EncoderFuzzer { |
672 | | private: |
673 | | Datasource& ds; |
674 | | lame_global_flags* flags = nullptr; |
675 | | uint8_t* outBuffer = nullptr; |
676 | | const size_t outBufferSize; |
677 | | bool mono = false; |
678 | | |
679 | 924 | void setBitrateModeVBR_RH(void) { |
680 | 924 | _(lame_set_VBR(flags, vbr_rh);); |
681 | 924 | } EncoderFuzzer<false>::setBitrateModeVBR_RH() Line | Count | Source | 679 | 924 | void setBitrateModeVBR_RH(void) { | 680 | 924 | _(lame_set_VBR(flags, vbr_rh);); | 681 | 924 | } |
Unexecuted instantiation: EncoderFuzzer<true>::setBitrateModeVBR_RH() |
682 | | |
683 | 1.46k | void setBitrateModeVBR_MTRH(void) { |
684 | 1.46k | _(lame_set_VBR(flags, vbr_mtrh);); |
685 | 1.46k | } EncoderFuzzer<false>::setBitrateModeVBR_MTRH() Line | Count | Source | 683 | 1.46k | void setBitrateModeVBR_MTRH(void) { | 684 | 1.46k | _(lame_set_VBR(flags, vbr_mtrh);); | 685 | 1.46k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setBitrateModeVBR_MTRH() |
686 | | |
687 | 0 | void setBitrateModeVBR_ABR(void) { |
688 | 0 | _(lame_set_VBR(flags, vbr_abr);); |
689 | 0 |
|
690 | 0 | const size_t ABRBitrate = limits::ABRBitrate.Generate(ds); |
691 | 0 |
|
692 | 0 | Debug ? printf("lame_set_VBR_mean_bitrate_kbps(flags, %zu);\n", ABRBitrate) : 0; |
693 | 0 |
|
694 | 0 | lame_set_VBR_mean_bitrate_kbps(flags, ABRBitrate); |
695 | 0 | } Unexecuted instantiation: EncoderFuzzer<false>::setBitrateModeVBR_ABR() Unexecuted instantiation: EncoderFuzzer<true>::setBitrateModeVBR_ABR() |
696 | | |
697 | 2.39k | void setVBRQ(void) { |
698 | 2.39k | if ( ds.Get<bool>() ) return; |
699 | | |
700 | 1.28k | const size_t vbrQ = limits::VBRQ.Generate<uint8_t>(ds); |
701 | | |
702 | 1.28k | Debug ? printf("lame_set_VBR_q(flags, %zu);\n", vbrQ) : 0; |
703 | | |
704 | 1.28k | lame_set_VBR_q(flags, vbrQ); |
705 | 1.28k | } EncoderFuzzer<false>::setVBRQ() Line | Count | Source | 697 | 2.39k | void setVBRQ(void) { | 698 | 2.39k | if ( ds.Get<bool>() ) return; | 699 | | | 700 | 1.28k | const size_t vbrQ = limits::VBRQ.Generate<uint8_t>(ds); | 701 | | | 702 | 1.28k | Debug ? printf("lame_set_VBR_q(flags, %zu);\n", vbrQ) : 0; | 703 | | | 704 | 1.28k | lame_set_VBR_q(flags, vbrQ); | 705 | 1.28k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setVBRQ() |
706 | | |
707 | 2.38k | size_t setMinBitrate(void) { |
708 | 2.38k | if ( ds.Get<bool>() ) return 0; |
709 | | |
710 | 723 | const size_t minBitrate = limits::MinBitrate.Generate(ds); |
711 | | |
712 | 723 | Debug ? printf("lame_set_VBR_min_bitrate_kbps(flags, %zu);\n", minBitrate) : 0; |
713 | | |
714 | 723 | lame_set_VBR_min_bitrate_kbps(flags, minBitrate); |
715 | | |
716 | 723 | return minBitrate; |
717 | 2.38k | } EncoderFuzzer<false>::setMinBitrate() Line | Count | Source | 707 | 2.38k | size_t setMinBitrate(void) { | 708 | 2.38k | if ( ds.Get<bool>() ) return 0; | 709 | | | 710 | 723 | const size_t minBitrate = limits::MinBitrate.Generate(ds); | 711 | | | 712 | 723 | Debug ? printf("lame_set_VBR_min_bitrate_kbps(flags, %zu);\n", minBitrate) : 0; | 713 | | | 714 | 723 | lame_set_VBR_min_bitrate_kbps(flags, minBitrate); | 715 | | | 716 | 723 | return minBitrate; | 717 | 2.38k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setMinBitrate() |
718 | | |
719 | 2.37k | void setMaxBitrate(const size_t minBitrate) { |
720 | 2.37k | if ( ds.Get<bool>() ) return; |
721 | | |
722 | 893 | size_t maxBitrate = limits::MaxBitrate.Generate(ds); |
723 | 893 | if ( minBitrate > maxBitrate ) { |
724 | | /* minBitrate should be <= maxBitrate, so if that is not the case, |
725 | | * set them both to the same value. |
726 | | */ |
727 | 61 | maxBitrate = minBitrate; |
728 | 61 | } |
729 | | |
730 | 893 | Debug ? printf("lame_set_VBR_max_bitrate_kbps(flags, %zu);\n", maxBitrate) : 0; |
731 | | |
732 | 893 | lame_set_VBR_max_bitrate_kbps(flags, maxBitrate); |
733 | 893 | } EncoderFuzzer<false>::setMaxBitrate(unsigned long) Line | Count | Source | 719 | 2.37k | void setMaxBitrate(const size_t minBitrate) { | 720 | 2.37k | if ( ds.Get<bool>() ) return; | 721 | | | 722 | 893 | size_t maxBitrate = limits::MaxBitrate.Generate(ds); | 723 | 893 | if ( minBitrate > maxBitrate ) { | 724 | | /* minBitrate should be <= maxBitrate, so if that is not the case, | 725 | | * set them both to the same value. | 726 | | */ | 727 | 61 | maxBitrate = minBitrate; | 728 | 61 | } | 729 | | | 730 | 893 | Debug ? printf("lame_set_VBR_max_bitrate_kbps(flags, %zu);\n", maxBitrate) : 0; | 731 | | | 732 | 893 | lame_set_VBR_max_bitrate_kbps(flags, maxBitrate); | 733 | 893 | } |
Unexecuted instantiation: EncoderFuzzer<true>::setMaxBitrate(unsigned long) |
734 | | |
735 | 2.39k | void setBitrateModeVBR(void) { |
736 | 2.39k | const uint8_t whichVbr = ds.Get<uint8_t>() % 3; |
737 | | |
738 | 2.39k | if ( whichVbr == 0 ) { |
739 | 924 | setBitrateModeVBR_RH(); |
740 | 1.46k | } else if ( whichVbr == 1 ) { |
741 | 1.46k | setBitrateModeVBR_MTRH(); |
742 | 1.46k | } else if ( whichVbr == 2 ) { |
743 | 1 | /* Disabled due to crash */ throw std::runtime_error(""); |
744 | 0 | setBitrateModeVBR_ABR(); |
745 | 0 | } |
746 | | |
747 | 2.39k | setVBRQ(); |
748 | | |
749 | 2.39k | size_t minBitrate = setMinBitrate(); |
750 | 2.39k | setMaxBitrate(minBitrate); |
751 | 2.39k | } EncoderFuzzer<false>::setBitrateModeVBR() Line | Count | Source | 735 | 2.39k | void setBitrateModeVBR(void) { | 736 | 2.39k | const uint8_t whichVbr = ds.Get<uint8_t>() % 3; | 737 | | | 738 | 2.39k | if ( whichVbr == 0 ) { | 739 | 924 | setBitrateModeVBR_RH(); | 740 | 1.46k | } else if ( whichVbr == 1 ) { | 741 | 1.46k | setBitrateModeVBR_MTRH(); | 742 | 1.46k | } else if ( whichVbr == 2 ) { | 743 | 1 | /* Disabled due to crash */ throw std::runtime_error(""); | 744 | 0 | setBitrateModeVBR_ABR(); | 745 | 0 | } | 746 | | | 747 | 2.39k | setVBRQ(); | 748 | | | 749 | 2.39k | size_t minBitrate = setMinBitrate(); | 750 | 2.39k | setMaxBitrate(minBitrate); | 751 | 2.39k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setBitrateModeVBR() |
752 | | |
753 | 4.42k | void setBitrateModeCBR(void) { |
754 | 4.42k | _(lame_set_VBR(flags, vbr_off);); |
755 | | |
756 | 4.42k | const size_t bitrate = limits::CBRBitrate.Generate(ds); |
757 | | |
758 | 4.42k | Debug ? printf("lame_set_brate(flags, %zu);\n", bitrate) : 0; |
759 | | |
760 | 4.42k | lame_set_brate(flags, bitrate); |
761 | 4.42k | } EncoderFuzzer<false>::setBitrateModeCBR() Line | Count | Source | 753 | 4.42k | void setBitrateModeCBR(void) { | 754 | 4.42k | _(lame_set_VBR(flags, vbr_off);); | 755 | | | 756 | 4.42k | const size_t bitrate = limits::CBRBitrate.Generate(ds); | 757 | | | 758 | 4.42k | Debug ? printf("lame_set_brate(flags, %zu);\n", bitrate) : 0; | 759 | | | 760 | 4.42k | lame_set_brate(flags, bitrate); | 761 | 4.42k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setBitrateModeCBR() |
762 | | |
763 | 6.82k | void setBitrateMode(void) { |
764 | 6.82k | ds.Get<bool>() ? setBitrateModeVBR() : setBitrateModeCBR(); |
765 | 6.82k | } EncoderFuzzer<false>::setBitrateMode() Line | Count | Source | 763 | 6.82k | void setBitrateMode(void) { | 764 | 6.82k | ds.Get<bool>() ? setBitrateModeVBR() : setBitrateModeCBR(); | 765 | 6.82k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setBitrateMode() |
766 | | |
767 | 6.82k | void setInputChannels(void) { |
768 | 6.82k | const int numChannels = ds.Get<bool>() ? 1 : 2; |
769 | | |
770 | 6.82k | Debug ? printf("lame_set_num_channels(flags, %d);\n", numChannels) : 0; |
771 | | |
772 | 6.82k | lame_set_num_channels(flags, numChannels); |
773 | | |
774 | 6.82k | if ( numChannels == 1 ) { |
775 | 1.45k | mono = true; |
776 | 1.45k | } |
777 | 6.82k | } EncoderFuzzer<false>::setInputChannels() Line | Count | Source | 767 | 6.82k | void setInputChannels(void) { | 768 | 6.82k | const int numChannels = ds.Get<bool>() ? 1 : 2; | 769 | | | 770 | 6.82k | Debug ? printf("lame_set_num_channels(flags, %d);\n", numChannels) : 0; | 771 | | | 772 | 6.82k | lame_set_num_channels(flags, numChannels); | 773 | | | 774 | 6.82k | if ( numChannels == 1 ) { | 775 | 1.45k | mono = true; | 776 | 1.45k | } | 777 | 6.82k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setInputChannels() |
778 | | |
779 | 6.73k | void setChannelMode(void) { |
780 | 6.73k | const uint8_t whichChannelMode = ds.Get<uint8_t>() % 3; |
781 | | |
782 | 6.73k | if ( whichChannelMode == 0 ) { |
783 | 3.00k | _(lame_set_mode(flags, STEREO);); |
784 | 3.73k | } else if ( whichChannelMode == 1 ) { |
785 | 2.55k | _(lame_set_mode(flags, JOINT_STEREO);); |
786 | 2.55k | } else if ( whichChannelMode == 2 ) { |
787 | 1.04k | _(lame_set_mode(flags, MONO);); |
788 | 1.04k | } |
789 | 6.73k | } EncoderFuzzer<false>::setChannelMode() Line | Count | Source | 779 | 6.73k | void setChannelMode(void) { | 780 | 6.73k | const uint8_t whichChannelMode = ds.Get<uint8_t>() % 3; | 781 | | | 782 | 6.73k | if ( whichChannelMode == 0 ) { | 783 | 3.00k | _(lame_set_mode(flags, STEREO);); | 784 | 3.73k | } else if ( whichChannelMode == 1 ) { | 785 | 2.55k | _(lame_set_mode(flags, JOINT_STEREO);); | 786 | 2.55k | } else if ( whichChannelMode == 2 ) { | 787 | 1.04k | _(lame_set_mode(flags, MONO);); | 788 | 1.04k | } | 789 | 6.73k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setChannelMode() |
790 | | |
791 | 6.60k | void setQuality(void) { |
792 | 6.60k | const size_t quality = limits::Quality.Generate<uint8_t>(ds); |
793 | | |
794 | 6.60k | Debug ? printf("lame_set_quality(flags, %zu);\n", quality) : 0; |
795 | | |
796 | 6.60k | lame_set_quality(flags, quality); |
797 | 6.60k | } EncoderFuzzer<false>::setQuality() Line | Count | Source | 791 | 6.60k | void setQuality(void) { | 792 | 6.60k | const size_t quality = limits::Quality.Generate<uint8_t>(ds); | 793 | | | 794 | 6.60k | Debug ? printf("lame_set_quality(flags, %zu);\n", quality) : 0; | 795 | | | 796 | 6.60k | lame_set_quality(flags, quality); | 797 | 6.60k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setQuality() |
798 | | |
799 | 6.60k | void setOutSamplerate(void) { |
800 | 6.60k | const size_t outSamplerate = limits::OutSamplerate.Generate(ds); |
801 | | |
802 | 6.60k | Debug ? printf("lame_set_out_samplerate(flags, %zu);\n", outSamplerate) : 0; |
803 | | |
804 | 6.60k | lame_set_out_samplerate(flags, outSamplerate); |
805 | 6.60k | } EncoderFuzzer<false>::setOutSamplerate() Line | Count | Source | 799 | 6.60k | void setOutSamplerate(void) { | 800 | 6.60k | const size_t outSamplerate = limits::OutSamplerate.Generate(ds); | 801 | | | 802 | 6.60k | Debug ? printf("lame_set_out_samplerate(flags, %zu);\n", outSamplerate) : 0; | 803 | | | 804 | 6.60k | lame_set_out_samplerate(flags, outSamplerate); | 805 | 6.60k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setOutSamplerate() |
806 | | |
807 | 6.59k | void setID3(void) { |
808 | | /* Optionally set various ID3 fields */ |
809 | | |
810 | 6.59k | if ( ds.Get<bool>() ) { |
811 | 1.31k | id3tag_init(flags); |
812 | | |
813 | 1.31k | if ( ds.Get<bool>() ) { |
814 | 147 | const std::string title = ds.Get<std::string>(); |
815 | | |
816 | 147 | Debug ? printf("id3tag_set_title(flags, %s);\n", title.c_str()) : 0; |
817 | | |
818 | 147 | id3tag_set_title(flags, title.c_str()); |
819 | 147 | } |
820 | | |
821 | 1.31k | if ( ds.Get<bool>() ) { |
822 | 151 | const std::string artist = ds.Get<std::string>(); |
823 | | |
824 | 151 | Debug ? printf("id3tag_set_artist(flags, %s);\n", artist.c_str()) : 0; |
825 | | |
826 | 151 | id3tag_set_artist(flags, artist.c_str()); |
827 | 151 | } |
828 | | |
829 | 1.31k | if ( ds.Get<bool>() ) { |
830 | 143 | const std::string album = ds.Get<std::string>(); |
831 | | |
832 | 143 | Debug ? printf("id3tag_set_album(flags, %s);\n", album.c_str()) : 0; |
833 | | |
834 | 143 | id3tag_set_album(flags, album.c_str()); |
835 | 143 | } |
836 | | |
837 | 1.31k | if ( ds.Get<bool>() ) { |
838 | 165 | const std::string year = ds.Get<std::string>(); |
839 | | |
840 | 165 | Debug ? printf("id3tag_set_year(flags, %s);\n", year.c_str()) : 0; |
841 | | |
842 | 165 | id3tag_set_year(flags, year.c_str()); |
843 | 165 | } |
844 | | |
845 | 1.31k | if ( ds.Get<bool>() ) { |
846 | 139 | const std::string comment = ds.Get<std::string>(); |
847 | | |
848 | 139 | Debug ? printf("id3tag_set_comment(flags, %s);\n", comment.c_str()) : 0; |
849 | | |
850 | 139 | id3tag_set_comment(flags, comment.c_str()); |
851 | 139 | } |
852 | | |
853 | 1.31k | if ( ds.Get<bool>() ) { |
854 | 137 | const std::string track = ds.Get<std::string>(); |
855 | | |
856 | 137 | Debug ? printf("id3tag_set_track(flags, %s);\n", track.c_str()) : 0; |
857 | | |
858 | 137 | id3tag_set_track(flags, track.c_str()); |
859 | 137 | } |
860 | | |
861 | 1.31k | if ( ds.Get<bool>() ) { |
862 | 251 | const std::string genre = ds.Get<std::string>(); |
863 | | |
864 | 251 | Debug ? printf("id3tag_set_genre(flags, %s);\n", genre.c_str()) : 0; |
865 | | |
866 | 251 | id3tag_set_genre(flags, genre.c_str()); |
867 | 251 | } |
868 | | |
869 | 1.31k | if ( ds.Get<bool>() ) { |
870 | 439 | const std::string fieldvalue = ds.Get<std::string>(); |
871 | | |
872 | 439 | Debug ? printf("id3tag_set_fieldvalue(flags, %s);\n", fieldvalue.c_str()) : 0; |
873 | | |
874 | 439 | id3tag_set_fieldvalue(flags, fieldvalue.c_str()); |
875 | 439 | } |
876 | | |
877 | 1.31k | if ( ds.Get<bool>() ) { |
878 | 158 | const auto albumArt = ds.GetData(0); |
879 | | |
880 | 158 | Debug ? printf("{\n") : 0; |
881 | | |
882 | 158 | Debug ? printf("\t%s\n", debug_define_size_t("albumArtSize", albumArt.size()).c_str()) : 0; |
883 | 158 | Debug ? printf("%s\n", DebugDefineArray<unsigned char>::Str("albumart", "char", albumArt.data(), albumArt.size(), true).c_str()) : 0; |
884 | | |
885 | 158 | Debug ? |
886 | 0 | printf("\tid3tag_set_albumart(flags, albumArt, albumArtSize);\n") |
887 | 158 | : 0; |
888 | | |
889 | 158 | Debug ? printf("}\n") : 0; |
890 | | |
891 | 158 | id3tag_set_albumart(flags, (const char*)albumArt.data(), albumArt.size()); |
892 | 158 | } |
893 | 1.31k | } |
894 | 6.59k | } EncoderFuzzer<false>::setID3() Line | Count | Source | 807 | 6.59k | void setID3(void) { | 808 | | /* Optionally set various ID3 fields */ | 809 | | | 810 | 6.59k | if ( ds.Get<bool>() ) { | 811 | 1.31k | id3tag_init(flags); | 812 | | | 813 | 1.31k | if ( ds.Get<bool>() ) { | 814 | 147 | const std::string title = ds.Get<std::string>(); | 815 | | | 816 | 147 | Debug ? printf("id3tag_set_title(flags, %s);\n", title.c_str()) : 0; | 817 | | | 818 | 147 | id3tag_set_title(flags, title.c_str()); | 819 | 147 | } | 820 | | | 821 | 1.31k | if ( ds.Get<bool>() ) { | 822 | 151 | const std::string artist = ds.Get<std::string>(); | 823 | | | 824 | 151 | Debug ? printf("id3tag_set_artist(flags, %s);\n", artist.c_str()) : 0; | 825 | | | 826 | 151 | id3tag_set_artist(flags, artist.c_str()); | 827 | 151 | } | 828 | | | 829 | 1.31k | if ( ds.Get<bool>() ) { | 830 | 143 | const std::string album = ds.Get<std::string>(); | 831 | | | 832 | 143 | Debug ? printf("id3tag_set_album(flags, %s);\n", album.c_str()) : 0; | 833 | | | 834 | 143 | id3tag_set_album(flags, album.c_str()); | 835 | 143 | } | 836 | | | 837 | 1.31k | if ( ds.Get<bool>() ) { | 838 | 165 | const std::string year = ds.Get<std::string>(); | 839 | | | 840 | 165 | Debug ? printf("id3tag_set_year(flags, %s);\n", year.c_str()) : 0; | 841 | | | 842 | 165 | id3tag_set_year(flags, year.c_str()); | 843 | 165 | } | 844 | | | 845 | 1.31k | if ( ds.Get<bool>() ) { | 846 | 139 | const std::string comment = ds.Get<std::string>(); | 847 | | | 848 | 139 | Debug ? printf("id3tag_set_comment(flags, %s);\n", comment.c_str()) : 0; | 849 | | | 850 | 139 | id3tag_set_comment(flags, comment.c_str()); | 851 | 139 | } | 852 | | | 853 | 1.31k | if ( ds.Get<bool>() ) { | 854 | 137 | const std::string track = ds.Get<std::string>(); | 855 | | | 856 | 137 | Debug ? printf("id3tag_set_track(flags, %s);\n", track.c_str()) : 0; | 857 | | | 858 | 137 | id3tag_set_track(flags, track.c_str()); | 859 | 137 | } | 860 | | | 861 | 1.31k | if ( ds.Get<bool>() ) { | 862 | 251 | const std::string genre = ds.Get<std::string>(); | 863 | | | 864 | 251 | Debug ? printf("id3tag_set_genre(flags, %s);\n", genre.c_str()) : 0; | 865 | | | 866 | 251 | id3tag_set_genre(flags, genre.c_str()); | 867 | 251 | } | 868 | | | 869 | 1.31k | if ( ds.Get<bool>() ) { | 870 | 439 | const std::string fieldvalue = ds.Get<std::string>(); | 871 | | | 872 | 439 | Debug ? printf("id3tag_set_fieldvalue(flags, %s);\n", fieldvalue.c_str()) : 0; | 873 | | | 874 | 439 | id3tag_set_fieldvalue(flags, fieldvalue.c_str()); | 875 | 439 | } | 876 | | | 877 | 1.31k | if ( ds.Get<bool>() ) { | 878 | 158 | const auto albumArt = ds.GetData(0); | 879 | | | 880 | 158 | Debug ? printf("{\n") : 0; | 881 | | | 882 | 158 | Debug ? printf("\t%s\n", debug_define_size_t("albumArtSize", albumArt.size()).c_str()) : 0; | 883 | 158 | Debug ? printf("%s\n", DebugDefineArray<unsigned char>::Str("albumart", "char", albumArt.data(), albumArt.size(), true).c_str()) : 0; | 884 | | | 885 | 158 | Debug ? | 886 | 0 | printf("\tid3tag_set_albumart(flags, albumArt, albumArtSize);\n") | 887 | 158 | : 0; | 888 | | | 889 | 158 | Debug ? printf("}\n") : 0; | 890 | | | 891 | 158 | id3tag_set_albumart(flags, (const char*)albumArt.data(), albumArt.size()); | 892 | 158 | } | 893 | 1.31k | } | 894 | 6.59k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setID3() |
895 | | |
896 | 5.58k | void setFilters(void) { |
897 | 5.58k | if ( ds.Get<bool>() ) { |
898 | 786 | const size_t lowpassFreq = limits::LowpassFrequency.Generate(ds); |
899 | | |
900 | 786 | Debug ? printf("lame_set_lowpassfreq(flags, %zu);\n", lowpassFreq) : 0; |
901 | | |
902 | 786 | lame_set_lowpassfreq(flags, lowpassFreq); |
903 | 786 | } |
904 | | |
905 | 5.58k | if ( ds.Get<bool>() ) { |
906 | 502 | const size_t lowpassWidth = limits::LowpassWidth.Generate(ds); |
907 | | |
908 | 502 | Debug ? printf("lame_set_lowpasswidth(flags, %zu);\n", lowpassWidth) : 0; |
909 | | |
910 | 502 | lame_set_lowpasswidth(flags, lowpassWidth); |
911 | 502 | } |
912 | | |
913 | 5.58k | if ( ds.Get<bool>() ) { |
914 | 623 | const size_t highpassFreq = limits::HighpassFrequency.Generate(ds); |
915 | | |
916 | 623 | Debug ? printf("lame_set_highpassfreq(flags, %zu);\n", highpassFreq) : 0; |
917 | | |
918 | 623 | lame_set_highpassfreq(flags, highpassFreq); |
919 | 623 | } |
920 | | |
921 | 5.58k | if ( ds.Get<bool>() ) { |
922 | 451 | const size_t highpassWidth = limits::HighpassWidth.Generate(ds); |
923 | | |
924 | 451 | Debug ? printf("lame_set_highpasswidth(flags, %zu);\n", highpassWidth) : 0; |
925 | | |
926 | 451 | lame_set_highpasswidth(flags, highpassWidth); |
927 | 451 | } |
928 | 5.58k | } EncoderFuzzer<false>::setFilters() Line | Count | Source | 896 | 5.58k | void setFilters(void) { | 897 | 5.58k | if ( ds.Get<bool>() ) { | 898 | 786 | const size_t lowpassFreq = limits::LowpassFrequency.Generate(ds); | 899 | | | 900 | 786 | Debug ? printf("lame_set_lowpassfreq(flags, %zu);\n", lowpassFreq) : 0; | 901 | | | 902 | 786 | lame_set_lowpassfreq(flags, lowpassFreq); | 903 | 786 | } | 904 | | | 905 | 5.58k | if ( ds.Get<bool>() ) { | 906 | 502 | const size_t lowpassWidth = limits::LowpassWidth.Generate(ds); | 907 | | | 908 | 502 | Debug ? printf("lame_set_lowpasswidth(flags, %zu);\n", lowpassWidth) : 0; | 909 | | | 910 | 502 | lame_set_lowpasswidth(flags, lowpassWidth); | 911 | 502 | } | 912 | | | 913 | 5.58k | if ( ds.Get<bool>() ) { | 914 | 623 | const size_t highpassFreq = limits::HighpassFrequency.Generate(ds); | 915 | | | 916 | 623 | Debug ? printf("lame_set_highpassfreq(flags, %zu);\n", highpassFreq) : 0; | 917 | | | 918 | 623 | lame_set_highpassfreq(flags, highpassFreq); | 919 | 623 | } | 920 | | | 921 | 5.58k | if ( ds.Get<bool>() ) { | 922 | 451 | const size_t highpassWidth = limits::HighpassWidth.Generate(ds); | 923 | | | 924 | 451 | Debug ? printf("lame_set_highpasswidth(flags, %zu);\n", highpassWidth) : 0; | 925 | | | 926 | 451 | lame_set_highpasswidth(flags, highpassWidth); | 927 | 451 | } | 928 | 5.58k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setFilters() |
929 | | |
930 | | |
931 | 5.27k | void setMisc(void) { |
932 | 5.27k | if ( ds.Get<bool>() ) { |
933 | 1.68k | _(lame_set_strict_ISO(flags, MDB_STRICT_ISO);); |
934 | 1.68k | } |
935 | | |
936 | 5.27k | if ( ds.Get<bool>() ) { |
937 | 1.72k | _(lame_set_bWriteVbrTag(flags, 1);); |
938 | 1.72k | } |
939 | | |
940 | 5.27k | if ( ds.Get<bool>() ) { |
941 | 1.84k | _(lame_set_copyright(flags, 1);); |
942 | 1.84k | } |
943 | | |
944 | 5.27k | if ( ds.Get<bool>() ) { |
945 | 1.78k | _(lame_set_original(flags, 1);); |
946 | 1.78k | } |
947 | | |
948 | 5.27k | if ( ds.Get<bool>() ) { |
949 | 2.10k | _(lame_set_error_protection(flags, 1);); |
950 | 2.10k | } |
951 | | |
952 | 5.27k | if ( ds.Get<bool>() ) { |
953 | 1.94k | _(lame_set_extension(flags, 1);); |
954 | 1.94k | } |
955 | | |
956 | 5.27k | if ( ds.Get<bool>() ) { |
957 | | /* Crashes */ |
958 | | /* _(lame_set_free_format(flags, 1);); */ |
959 | 2.06k | } |
960 | 5.27k | } EncoderFuzzer<false>::setMisc() Line | Count | Source | 931 | 5.27k | void setMisc(void) { | 932 | 5.27k | if ( ds.Get<bool>() ) { | 933 | 1.68k | _(lame_set_strict_ISO(flags, MDB_STRICT_ISO);); | 934 | 1.68k | } | 935 | | | 936 | 5.27k | if ( ds.Get<bool>() ) { | 937 | 1.72k | _(lame_set_bWriteVbrTag(flags, 1);); | 938 | 1.72k | } | 939 | | | 940 | 5.27k | if ( ds.Get<bool>() ) { | 941 | 1.84k | _(lame_set_copyright(flags, 1);); | 942 | 1.84k | } | 943 | | | 944 | 5.27k | if ( ds.Get<bool>() ) { | 945 | 1.78k | _(lame_set_original(flags, 1);); | 946 | 1.78k | } | 947 | | | 948 | 5.27k | if ( ds.Get<bool>() ) { | 949 | 2.10k | _(lame_set_error_protection(flags, 1);); | 950 | 2.10k | } | 951 | | | 952 | 5.27k | if ( ds.Get<bool>() ) { | 953 | 1.94k | _(lame_set_extension(flags, 1);); | 954 | 1.94k | } | 955 | | | 956 | 5.27k | if ( ds.Get<bool>() ) { | 957 | | /* Crashes */ | 958 | | /* _(lame_set_free_format(flags, 1);); */ | 959 | 2.06k | } | 960 | 5.27k | } |
Unexecuted instantiation: EncoderFuzzer<true>::setMisc() |
961 | | |
962 | | public: |
963 | | EncoderFuzzer(Datasource& ds) : |
964 | | ds(ds), outBufferSize(limits::OutBufferSize.Generate(ds)) |
965 | 7.34k | { |
966 | 7.34k | Debug ? |
967 | 0 | printf("lame_global_flags* flags = lame_init();\n") |
968 | 7.34k | : 0; |
969 | 7.34k | flags = lame_init(); |
970 | | |
971 | 7.34k | Debug ? |
972 | 0 | printf("const size_t outBufferSize = %zu;\n", outBufferSize) |
973 | 7.34k | : 0; |
974 | 7.34k | Debug ? |
975 | 0 | printf("unsigned char outBuffer[outBufferSize];\n") |
976 | 7.34k | : 0; |
977 | | |
978 | 7.34k | outBuffer = (uint8_t*)malloc(outBufferSize + 1024 /* Add 1024 due to crash */); |
979 | 7.34k | } EncoderFuzzer<false>::EncoderFuzzer(fuzzing::datasource::Datasource&) Line | Count | Source | 965 | 7.34k | { | 966 | 7.34k | Debug ? | 967 | 0 | printf("lame_global_flags* flags = lame_init();\n") | 968 | 7.34k | : 0; | 969 | 7.34k | flags = lame_init(); | 970 | | | 971 | 7.34k | Debug ? | 972 | 0 | printf("const size_t outBufferSize = %zu;\n", outBufferSize) | 973 | 7.34k | : 0; | 974 | 7.34k | Debug ? | 975 | 0 | printf("unsigned char outBuffer[outBufferSize];\n") | 976 | 7.34k | : 0; | 977 | | | 978 | 7.34k | outBuffer = (uint8_t*)malloc(outBufferSize + 1024 /* Add 1024 due to crash */); | 979 | 7.34k | } |
Unexecuted instantiation: EncoderFuzzer<true>::EncoderFuzzer(fuzzing::datasource::Datasource&) |
980 | | |
981 | 7.28k | void Run(void) { |
982 | | |
983 | 7.28k | std::unique_ptr<EncoderCoreBase> encoder = nullptr; |
984 | | |
985 | 7.28k | const uint8_t whichSampleSize = ds.Get<uint8_t>() % 5; |
986 | | |
987 | 7.28k | if ( whichSampleSize == 0 ) { |
988 | 4.25k | encoder = std::make_unique<EncoderCore<short int, Debug>>(ds, flags); |
989 | 4.25k | } else if ( whichSampleSize == 1 ) { |
990 | 599 | encoder = std::make_unique<EncoderCore<int, Debug>>(ds, flags); |
991 | 2.43k | } else if ( whichSampleSize == 2 ) { |
992 | 914 | encoder = std::make_unique<EncoderCore<long, Debug>>(ds, flags); |
993 | 1.52k | } else if ( whichSampleSize == 3 ) { |
994 | 840 | encoder = std::make_unique<EncoderCore<float, Debug>>(ds, flags); |
995 | 840 | } else if ( whichSampleSize == 4 ) { |
996 | 610 | encoder = std::make_unique<EncoderCore<double, Debug>>(ds, flags); |
997 | 610 | } |
998 | | |
999 | 7.28k | setInputChannels(); |
1000 | 7.28k | setBitrateMode(); |
1001 | 7.28k | setChannelMode(); |
1002 | 7.28k | setQuality(); |
1003 | 7.28k | setOutSamplerate(); |
1004 | 7.28k | setID3(); |
1005 | 7.28k | setFilters(); |
1006 | 7.28k | setMisc(); |
1007 | | |
1008 | 7.28k | Debug ? printf("lame_init_params(flags);\n") : 0; |
1009 | | |
1010 | 7.28k | if ( lame_init_params(flags) == -1 ) { |
1011 | 0 | abort(); |
1012 | 0 | } |
1013 | | |
1014 | 13.7k | while ( encoder->Run(outBuffer, outBufferSize, mono) ) { } |
1015 | 7.28k | } EncoderFuzzer<false>::Run() Line | Count | Source | 981 | 7.28k | void Run(void) { | 982 | | | 983 | 7.28k | std::unique_ptr<EncoderCoreBase> encoder = nullptr; | 984 | | | 985 | 7.28k | const uint8_t whichSampleSize = ds.Get<uint8_t>() % 5; | 986 | | | 987 | 7.28k | if ( whichSampleSize == 0 ) { | 988 | 4.25k | encoder = std::make_unique<EncoderCore<short int, Debug>>(ds, flags); | 989 | 4.25k | } else if ( whichSampleSize == 1 ) { | 990 | 599 | encoder = std::make_unique<EncoderCore<int, Debug>>(ds, flags); | 991 | 2.43k | } else if ( whichSampleSize == 2 ) { | 992 | 914 | encoder = std::make_unique<EncoderCore<long, Debug>>(ds, flags); | 993 | 1.52k | } else if ( whichSampleSize == 3 ) { | 994 | 840 | encoder = std::make_unique<EncoderCore<float, Debug>>(ds, flags); | 995 | 840 | } else if ( whichSampleSize == 4 ) { | 996 | 610 | encoder = std::make_unique<EncoderCore<double, Debug>>(ds, flags); | 997 | 610 | } | 998 | | | 999 | 7.28k | setInputChannels(); | 1000 | 7.28k | setBitrateMode(); | 1001 | 7.28k | setChannelMode(); | 1002 | 7.28k | setQuality(); | 1003 | 7.28k | setOutSamplerate(); | 1004 | 7.28k | setID3(); | 1005 | 7.28k | setFilters(); | 1006 | 7.28k | setMisc(); | 1007 | | | 1008 | 7.28k | Debug ? printf("lame_init_params(flags);\n") : 0; | 1009 | | | 1010 | 7.28k | if ( lame_init_params(flags) == -1 ) { | 1011 | 0 | abort(); | 1012 | 0 | } | 1013 | | | 1014 | 13.7k | while ( encoder->Run(outBuffer, outBufferSize, mono) ) { } | 1015 | 7.28k | } |
Unexecuted instantiation: EncoderFuzzer<true>::Run() |
1016 | | |
1017 | 7.28k | ~EncoderFuzzer() { |
1018 | 7.28k | lame_close(flags); |
1019 | 7.28k | free(outBuffer); |
1020 | 7.28k | outBuffer = nullptr; |
1021 | 7.28k | } EncoderFuzzer<false>::~EncoderFuzzer() Line | Count | Source | 1017 | 7.28k | ~EncoderFuzzer() { | 1018 | 7.28k | lame_close(flags); | 1019 | 7.28k | free(outBuffer); | 1020 | 7.28k | outBuffer = nullptr; | 1021 | 7.28k | } |
Unexecuted instantiation: EncoderFuzzer<true>::~EncoderFuzzer() |
1022 | | }; |
1023 | | |
1024 | | static bool debug = false; |
1025 | | |
1026 | | extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) |
1027 | 2 | { |
1028 | 2 | char** _argv = *argv; |
1029 | 13 | for (int i = 0; i < *argc; i++) { |
1030 | 11 | if ( std::string(_argv[i]) == "--debug") { |
1031 | 0 | debug = true; |
1032 | 0 | } |
1033 | 11 | } |
1034 | | |
1035 | 2 | return 0; |
1036 | 2 | } |
1037 | | |
1038 | | extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) |
1039 | 7.34k | { |
1040 | 7.34k | Datasource ds(data, size); |
1041 | | |
1042 | 7.34k | try { |
1043 | 7.34k | if ( debug == false ) { |
1044 | 7.34k | EncoderFuzzer<false> encoder(ds); |
1045 | 7.34k | encoder.Run(); |
1046 | 7.34k | } else { |
1047 | 0 | EncoderFuzzer<true> encoder(ds); |
1048 | 0 | encoder.Run(); |
1049 | 0 | } |
1050 | 7.34k | } catch ( ... ) { } |
1051 | | |
1052 | 7.34k | return 0; |
1053 | 7.34k | } |