?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow using a negative offset with callback buffers
[openal-soft.git] / utils / uhjencoder.cpp
blob34698993ac12b5ac5cc0347a007f6f275b636ddd
1 /*
2 * 2-channel UHJ Encoder
3 *
4 * Copyright (c) Chris Robinson <chris.kcat@gmail.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "config.h"
26
27 #include <array>
28 #include <cstring>
29 #include <inttypes.h>
30 #include <memory>
31 #include <stddef.h>
32 #include <string>
33 #include <utility>
34 #include <vector>
35
36 #include "almalloc.h"
37 #include "alnumbers.h"
38 #include "alspan.h"
39 #include "opthelpers.h"
40 #include "phase_shifter.h"
41 #include "vector.h"
42
43 #include "sndfile.h"
44
45 #include "win_main_utf8.h"
46
47
48 namespace {
49
50 struct SndFileDeleter {
51 void operator()(SNDFILE *sndfile) { sf_close(sndfile); }
52 };
53 using SndFilePtr = std::unique_ptr<SNDFILE,SndFileDeleter>;
54
55
56 using uint = unsigned int;
57
58 constexpr uint BufferLineSize{1024};
59
60 using FloatBufferLine = std::array<float,BufferLineSize>;
61 using FloatBufferSpan = al::span<float,BufferLineSize>;
62
63
64 struct UhjEncoder {
65 constexpr static size_t sFilterDelay{1024};
66
67 /* Delays and processing storage for the unfiltered signal. */
68 alignas(16) std::array<float,BufferLineSize+sFilterDelay> mW{};
69 alignas(16) std::array<float,BufferLineSize+sFilterDelay> mX{};
70 alignas(16) std::array<float,BufferLineSize+sFilterDelay> mY{};
71 alignas(16) std::array<float,BufferLineSize+sFilterDelay> mZ{};
72
73 alignas(16) std::array<float,BufferLineSize> mS{};
74 alignas(16) std::array<float,BufferLineSize> mD{};
75 alignas(16) std::array<float,BufferLineSize> mT{};
76
77 /* History for the FIR filter. */
78 alignas(16) std::array<float,sFilterDelay*2 - 1> mWXHistory1{};
79 alignas(16) std::array<float,sFilterDelay*2 - 1> mWXHistory2{};
80
81 alignas(16) std::array<float,BufferLineSize + sFilterDelay*2> mTemp{};
82
83 void encode(const al::span<FloatBufferLine> OutSamples,
84 const al::span<FloatBufferLine,4> InSamples, const size_t SamplesToDo);
85
86 DEF_NEWDEL(UhjEncoder)
87 };
88
89 const PhaseShifterT<UhjEncoder::sFilterDelay*2> PShift{};
90
91
92 /* Encoding UHJ from B-Format is done as:
93 *
94 * S = 0.9396926*W + 0.1855740*X
95 * D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y
96 *
97 * Left = (S + D)/2.0
98 * Right = (S - D)/2.0
99 * T = j(-0.1432*W + 0.6512*X) - 0.7071068*Y
100 * Q = 0.9772*Z
101 *
102 * where j is a wide-band +90 degree phase shift. T is excluded from 2-channel
103 * output, and Q is excluded from 2- and 3-channel output.
104 */
105 void UhjEncoder::encode(const al::span<FloatBufferLine> OutSamples,
106 const al::span<FloatBufferLine,4> InSamples, const size_t SamplesToDo)
107 {
108 const float *RESTRICT winput{al::assume_aligned<16>(InSamples[0].data())};
109 const float *RESTRICT xinput{al::assume_aligned<16>(InSamples[1].data())};
110 const float *RESTRICT yinput{al::assume_aligned<16>(InSamples[2].data())};
111 const float *RESTRICT zinput{al::assume_aligned<16>(InSamples[3].data())};
112
113 /* Combine the previously delayed input signal with the new input. */
114 std::copy_n(winput, SamplesToDo, mW.begin()+sFilterDelay);
115 std::copy_n(xinput, SamplesToDo, mX.begin()+sFilterDelay);
116 std::copy_n(yinput, SamplesToDo, mY.begin()+sFilterDelay);
117 std::copy_n(zinput, SamplesToDo, mZ.begin()+sFilterDelay);
118
119 /* S = 0.9396926*W + 0.1855740*X */
120 for(size_t i{0};i < SamplesToDo;++i)
121 mS[i] = 0.9396926f*mW[i] + 0.1855740f*mX[i];
122
123 /* Precompute j(-0.3420201*W + 0.5098604*X) and store in mD. */
124 auto tmpiter = std::copy(mWXHistory1.cbegin(), mWXHistory1.cend(), mTemp.begin());
125 std::transform(winput, winput+SamplesToDo, xinput, tmpiter,
126 [](const float w, const float x) noexcept -> float
127 { return -0.3420201f*w + 0.5098604f*x; });
128 std::copy_n(mTemp.cbegin()+SamplesToDo, mWXHistory1.size(), mWXHistory1.begin());
129 PShift.process({mD.data(), SamplesToDo}, mTemp.data());
130
131 /* D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y */
132 for(size_t i{0};i < SamplesToDo;++i)
133 mD[i] = mD[i] + 0.6554516f*mY[i];
134
135 /* Left = (S + D)/2.0 */
136 float *RESTRICT left{al::assume_aligned<16>(OutSamples[0].data())};
137 for(size_t i{0};i < SamplesToDo;i++)
138 left[i] = (mS[i] + mD[i]) * 0.5f;
139 /* Right = (S - D)/2.0 */
140 float *RESTRICT right{al::assume_aligned<16>(OutSamples[1].data())};
141 for(size_t i{0};i < SamplesToDo;i++)
142 right[i] = (mS[i] - mD[i]) * 0.5f;
143
144 if(OutSamples.size() > 2)
145 {
146 /* Precompute j(-0.1432*W + 0.6512*X) and store in mT. */
147 tmpiter = std::copy(mWXHistory2.cbegin(), mWXHistory2.cend(), mTemp.begin());
148 std::transform(winput, winput+SamplesToDo, xinput, tmpiter,
149 [](const float w, const float x) noexcept -> float
150 { return -0.1432f*w + 0.6512f*x; });
151 std::copy_n(mTemp.cbegin()+SamplesToDo, mWXHistory2.size(), mWXHistory2.begin());
152 PShift.process({mT.data(), SamplesToDo}, mTemp.data());
153
154 /* T = j(-0.1432*W + 0.6512*X) - 0.7071068*Y */
155 float *RESTRICT t{al::assume_aligned<16>(OutSamples[2].data())};
156 for(size_t i{0};i < SamplesToDo;i++)
157 t[i] = mT[i] - 0.7071068f*mY[i];
158 }
159 if(OutSamples.size() > 3)
160 {
161 /* Q = 0.9772*Z */
162 float *RESTRICT q{al::assume_aligned<16>(OutSamples[3].data())};
163 for(size_t i{0};i < SamplesToDo;i++)
164 q[i] = 0.9772f*mZ[i];
165 }
166
167 /* Copy the future samples to the front for next time. */
168 std::copy(mW.cbegin()+SamplesToDo, mW.cbegin()+SamplesToDo+sFilterDelay, mW.begin());
169 std::copy(mX.cbegin()+SamplesToDo, mX.cbegin()+SamplesToDo+sFilterDelay, mX.begin());
170 std::copy(mY.cbegin()+SamplesToDo, mY.cbegin()+SamplesToDo+sFilterDelay, mY.begin());
171 std::copy(mZ.cbegin()+SamplesToDo, mZ.cbegin()+SamplesToDo+sFilterDelay, mZ.begin());
172 }
173
174
175 struct SpeakerPos {
176 int mChannelID;
177 float mAzimuth;
178 float mElevation;
179 };
180
181 /* Azimuth is counter-clockwise. */
182 constexpr SpeakerPos StereoMap[2]{
183 { SF_CHANNEL_MAP_LEFT, 30.0f, 0.0f },
184 { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
185 }, QuadMap[4]{
186 { SF_CHANNEL_MAP_LEFT, 45.0f, 0.0f },
187 { SF_CHANNEL_MAP_RIGHT, -45.0f, 0.0f },
188 { SF_CHANNEL_MAP_REAR_LEFT, 135.0f, 0.0f },
189 { SF_CHANNEL_MAP_REAR_RIGHT, -135.0f, 0.0f },
190 }, X51Map[6]{
191 { SF_CHANNEL_MAP_LEFT, 30.0f, 0.0f },
192 { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
193 { SF_CHANNEL_MAP_CENTER, 0.0f, 0.0f },
194 { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
195 { SF_CHANNEL_MAP_SIDE_LEFT, 110.0f, 0.0f },
196 { SF_CHANNEL_MAP_SIDE_RIGHT, -110.0f, 0.0f },
197 }, X51RearMap[6]{
198 { SF_CHANNEL_MAP_LEFT, 30.0f, 0.0f },
199 { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
200 { SF_CHANNEL_MAP_CENTER, 0.0f, 0.0f },
201 { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
202 { SF_CHANNEL_MAP_REAR_LEFT, 110.0f, 0.0f },
203 { SF_CHANNEL_MAP_REAR_RIGHT, -110.0f, 0.0f },
204 }, X71Map[8]{
205 { SF_CHANNEL_MAP_LEFT, 30.0f, 0.0f },
206 { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
207 { SF_CHANNEL_MAP_CENTER, 0.0f, 0.0f },
208 { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
209 { SF_CHANNEL_MAP_REAR_LEFT, 150.0f, 0.0f },
210 { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f, 0.0f },
211 { SF_CHANNEL_MAP_SIDE_LEFT, 90.0f, 0.0f },
212 { SF_CHANNEL_MAP_SIDE_RIGHT, -90.0f, 0.0f },
213 }, X714Map[12]{
214 { SF_CHANNEL_MAP_LEFT, 30.0f, 0.0f },
215 { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
216 { SF_CHANNEL_MAP_CENTER, 0.0f, 0.0f },
217 { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
218 { SF_CHANNEL_MAP_REAR_LEFT, 150.0f, 0.0f },
219 { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f, 0.0f },
220 { SF_CHANNEL_MAP_SIDE_LEFT, 90.0f, 0.0f },
221 { SF_CHANNEL_MAP_SIDE_RIGHT, -90.0f, 0.0f },
222 { SF_CHANNEL_MAP_TOP_FRONT_LEFT, 45.0f, 35.0f },
223 { SF_CHANNEL_MAP_TOP_FRONT_RIGHT, -45.0f, 35.0f },
224 { SF_CHANNEL_MAP_TOP_REAR_LEFT, 135.0f, 35.0f },
225 { SF_CHANNEL_MAP_TOP_REAR_RIGHT, -135.0f, 35.0f },
226 };
227
228 constexpr auto GenCoeffs(double x /*+front*/, double y /*+left*/, double z /*+up*/) noexcept
229 {
230 /* Coefficients are +3dB of FuMa. */
231 return std::array<float,4>{{
232 1.0f,
233 static_cast<float>(al::numbers::sqrt2 * x),
234 static_cast<float>(al::numbers::sqrt2 * y),
235 static_cast<float>(al::numbers::sqrt2 * z)
236 }};
237 }
238
239 } // namespace
240
241
242 int main(int argc, char **argv)
243 {
244 if(argc < 2 || std::strcmp(argv[1], "-h") == 0 || std::strcmp(argv[1], "--help") == 0)
245 {
246 printf("Usage: %s <infile...>\n\n", argv[0]);
247 return 1;
248 }
249
250 uint uhjchans{2};
251 size_t num_files{0}, num_encoded{0};
252 for(int fidx{1};fidx < argc;++fidx)
253 {
254 if(strcmp(argv[fidx], "-bhj") == 0)
255 {
256 uhjchans = 2;
257 continue;
258 }
259 if(strcmp(argv[fidx], "-thj") == 0)
260 {
261 uhjchans = 3;
262 continue;
263 }
264 if(strcmp(argv[fidx], "-phj") == 0)
265 {
266 uhjchans = 4;
267 continue;
268 }
269 ++num_files;
270
271 std::string outname{argv[fidx]};
272 size_t lastslash{outname.find_last_of('/')};
273 if(lastslash != std::string::npos)
274 outname.erase(0, lastslash+1);
275 size_t extpos{outname.find_last_of('.')};
276 if(extpos != std::string::npos)
277 outname.resize(extpos);
278 outname += ".uhj.flac";
279
280 SF_INFO ininfo{};
281 SndFilePtr infile{sf_open(argv[fidx], SFM_READ, &ininfo)};
282 if(!infile)
283 {
284 fprintf(stderr, "Failed to open %s\n", argv[fidx]);
285 continue;
286 }
287 printf("Converting %s to %s...\n", argv[fidx], outname.c_str());
288
289 /* Work out the channel map, preferably using the actual channel map
290 * from the file/format, but falling back to assuming WFX order.
291 */
292 al::span<const SpeakerPos> spkrs;
293 auto chanmap = std::vector<int>(static_cast<uint>(ininfo.channels), SF_CHANNEL_MAP_INVALID);
294 if(sf_command(infile.get(), SFC_GET_CHANNEL_MAP_INFO, chanmap.data(),
295 ininfo.channels*int{sizeof(int)}) == SF_TRUE)
296 {
297 static const std::array<int,2> stereomap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT}};
298 static const std::array<int,4> quadmap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
299 SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT}};
300 static const std::array<int,6> x51map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
301 SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
302 SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT}};
303 static const std::array<int,6> x51rearmap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
304 SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
305 SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT}};
306 static const std::array<int,8> x71map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
307 SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
308 SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT,
309 SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT}};
310 static const std::array<int,12> x714map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
311 SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
312 SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT,
313 SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT,
314 SF_CHANNEL_MAP_TOP_FRONT_LEFT, SF_CHANNEL_MAP_TOP_FRONT_RIGHT,
315 SF_CHANNEL_MAP_TOP_REAR_LEFT, SF_CHANNEL_MAP_TOP_REAR_RIGHT}};
316 static const std::array<int,3> ambi2dmap{{SF_CHANNEL_MAP_AMBISONIC_B_W,
317 SF_CHANNEL_MAP_AMBISONIC_B_X, SF_CHANNEL_MAP_AMBISONIC_B_Y}};
318 static const std::array<int,4> ambi3dmap{{SF_CHANNEL_MAP_AMBISONIC_B_W,
319 SF_CHANNEL_MAP_AMBISONIC_B_X, SF_CHANNEL_MAP_AMBISONIC_B_Y,
320 SF_CHANNEL_MAP_AMBISONIC_B_Z}};
321
322 auto match_chanmap = [](const al::span<int> a, const al::span<const int> b) -> bool
323 {
324 if(a.size() != b.size())
325 return false;
326 for(const int id : a)
327 {
328 if(std::find(b.begin(), b.end(), id) != b.end())
329 return false;
330 }
331 return true;
332 };
333 if(match_chanmap(chanmap, stereomap))
334 spkrs = StereoMap;
335 else if(match_chanmap(chanmap, quadmap))
336 spkrs = QuadMap;
337 else if(match_chanmap(chanmap, x51map))
338 spkrs = X51Map;
339 else if(match_chanmap(chanmap, x51rearmap))
340 spkrs = X51RearMap;
341 else if(match_chanmap(chanmap, x71map))
342 spkrs = X71Map;
343 else if(match_chanmap(chanmap, x714map))
344 spkrs = X714Map;
345 else if(match_chanmap(chanmap, ambi2dmap) || match_chanmap(chanmap, ambi3dmap))
346 {
347 /* Do nothing. */
348 }
349 else
350 {
351 std::string mapstr;
352 if(!chanmap.empty())
353 {
354 mapstr = std::to_string(chanmap[0]);
355 for(int idx : al::span<int>{chanmap}.subspan<1>())
356 {
357 mapstr += ',';
358 mapstr += std::to_string(idx);
359 }
360 }
361 fprintf(stderr, " ... %zu channels not supported (map: %s)\n", chanmap.size(),
362 mapstr.c_str());
363 continue;
364 }
365 }
366 else if(ininfo.channels == 2)
367 {
368 fprintf(stderr, " ... assuming WFX order stereo\n");
369 spkrs = StereoMap;
370 chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
371 chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
372 }
373 else if(ininfo.channels == 6)
374 {
375 fprintf(stderr, " ... assuming WFX order 5.1\n");
376 spkrs = X51Map;
377 chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
378 chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
379 chanmap[2] = SF_CHANNEL_MAP_FRONT_CENTER;
380 chanmap[3] = SF_CHANNEL_MAP_LFE;
381 chanmap[4] = SF_CHANNEL_MAP_SIDE_LEFT;
382 chanmap[5] = SF_CHANNEL_MAP_SIDE_RIGHT;
383 }
384 else if(ininfo.channels == 8)
385 {
386 fprintf(stderr, " ... assuming WFX order 7.1\n");
387 spkrs = X71Map;
388 chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
389 chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
390 chanmap[2] = SF_CHANNEL_MAP_FRONT_CENTER;
391 chanmap[3] = SF_CHANNEL_MAP_LFE;
392 chanmap[4] = SF_CHANNEL_MAP_REAR_LEFT;
393 chanmap[5] = SF_CHANNEL_MAP_REAR_RIGHT;
394 chanmap[6] = SF_CHANNEL_MAP_SIDE_LEFT;
395 chanmap[7] = SF_CHANNEL_MAP_SIDE_RIGHT;
396 }
397 else
398 {
399 fprintf(stderr, " ... unmapped %d-channel audio not supported\n", ininfo.channels);
400 continue;
401 }
402
403 SF_INFO outinfo{};
404 outinfo.frames = ininfo.frames;
405 outinfo.samplerate = ininfo.samplerate;
406 outinfo.channels = static_cast<int>(uhjchans);
407 outinfo.format = SF_FORMAT_PCM_24 | SF_FORMAT_FLAC;
408 SndFilePtr outfile{sf_open(outname.c_str(), SFM_WRITE, &outinfo)};
409 if(!outfile)
410 {
411 fprintf(stderr, " ... failed to create %s\n", outname.c_str());
412 continue;
413 }
414
415 auto encoder = std::make_unique<UhjEncoder>();
416 auto splbuf = al::vector<FloatBufferLine, 16>(static_cast<uint>(9+ininfo.channels)+uhjchans);
417 auto ambmem = al::span<FloatBufferLine,4>{splbuf.data(), 4};
418 auto encmem = al::span<FloatBufferLine,4>{&splbuf[4], 4};
419 auto srcmem = al::span<float,BufferLineSize>{splbuf[8].data(), BufferLineSize};
420 auto outmem = al::span<float>{splbuf[9].data(), BufferLineSize*uhjchans};
421
422 /* A number of initial samples need to be skipped to cut the lead-in
423 * from the all-pass filter delay. The same number of samples need to
424 * be fed through the encoder after reaching the end of the input file
425 * to ensure none of the original input is lost.
426 */
427 size_t total_wrote{0};
428 size_t LeadIn{UhjEncoder::sFilterDelay};
429 sf_count_t LeadOut{UhjEncoder::sFilterDelay};
430 while(LeadIn > 0 || LeadOut > 0)
431 {
432 auto inmem = outmem.data() + outmem.size();
433 auto sgot = sf_readf_float(infile.get(), inmem, BufferLineSize);
434
435 sgot = std::max<sf_count_t>(sgot, 0);
436 if(sgot < BufferLineSize)
437 {
438 const sf_count_t remaining{std::min(BufferLineSize - sgot, LeadOut)};
439 std::fill_n(inmem + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
440 sgot += remaining;
441 LeadOut -= remaining;
442 }
443
444 for(auto&& buf : ambmem)
445 buf.fill(0.0f);
446
447 auto got = static_cast<size_t>(sgot);
448 if(spkrs.empty())
449 {
450 /* B-Format is already in the correct order. It just needs a
451 * +3dB boost.
452 */
453 static constexpr float scale{al::numbers::sqrt2_v<float>};
454 const size_t chans{std::min<size_t>(static_cast<uint>(ininfo.channels), 4u)};
455 for(size_t c{0};c < chans;++c)
456 {
457 for(size_t i{0};i < got;++i)
458 ambmem[c][i] = inmem[i*static_cast<uint>(ininfo.channels)] * scale;
459 ++inmem;
460 }
461 }
462 else for(const int chanid : chanmap)
463 {
464 /* Skip LFE. Or mix directly into W? Or W+X? */
465 if(chanid == SF_CHANNEL_MAP_LFE)
466 {
467 ++inmem;
468 continue;
469 }
470
471 const auto spkr = std::find_if(spkrs.cbegin(), spkrs.cend(),
472 [chanid](const SpeakerPos &pos){return pos.mChannelID == chanid;});
473 if(spkr == spkrs.cend())
474 {
475 fprintf(stderr, " ... failed to find channel ID %d\n", chanid);
476 continue;
477 }
478
479 for(size_t i{0};i < got;++i)
480 srcmem[i] = inmem[i * static_cast<uint>(ininfo.channels)];
481 ++inmem;
482
483 static constexpr auto Deg2Rad = al::numbers::pi / 180.0;
484 const auto coeffs = GenCoeffs(
485 std::cos(spkr->mAzimuth*Deg2Rad) * std::cos(spkr->mElevation*Deg2Rad),
486 std::sin(spkr->mAzimuth*Deg2Rad) * std::cos(spkr->mElevation*Deg2Rad),
487 std::sin(spkr->mElevation*Deg2Rad));
488 for(size_t c{0};c < 4;++c)
489 {
490 for(size_t i{0};i < got;++i)
491 ambmem[c][i] += srcmem[i] * coeffs[c];
492 }
493 }
494
495 encoder->encode(encmem.subspan(0, uhjchans), ambmem, got);
496 if(LeadIn >= got)
497 {
498 LeadIn -= got;
499 continue;
500 }
501
502 got -= LeadIn;
503 for(size_t c{0};c < uhjchans;++c)
504 {
505 constexpr float max_val{8388607.0f / 8388608.0f};
506 auto clamp = [](float v, float mn, float mx) noexcept
507 { return std::min(std::max(v, mn), mx); };
508 for(size_t i{0};i < got;++i)
509 outmem[i*uhjchans + c] = clamp(encmem[c][LeadIn+i], -1.0f, max_val);
510 }
511 LeadIn = 0;
512
513 sf_count_t wrote{sf_writef_float(outfile.get(), outmem.data(),
514 static_cast<sf_count_t>(got))};
515 if(wrote < 0)
516 fprintf(stderr, " ... failed to write samples: %d\n", sf_error(outfile.get()));
517 else
518 total_wrote += static_cast<size_t>(wrote);
519 }
520 printf(" ... wrote %zu samples (%" PRId64 ").\n", total_wrote, int64_t{ininfo.frames});
521 ++num_encoded;
522 }
523 if(num_encoded == 0)
524 fprintf(stderr, "Failed to encode any input files\n");
525 else if(num_encoded < num_files)
526 fprintf(stderr, "Encoded %zu of %zu files\n", num_encoded, num_files);
527 else
528 printf("Encoded %s%zu file%s\n", (num_encoded > 1) ? "all " : "", num_encoded,
529 (num_encoded == 1) ? "" : "s");
530 return 0;
531 }
Software OpenAL implementation