falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6859 Commits
17 Branches
992MB
Tree: e77ec91bda
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e77ec91bda'
${ noResults }
Carla/source/native-plugins/audio-base.hpp

923 lines
29KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2013-2023 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the GPL.txt file

  16.  */

  17. 

  18. #ifndef AUDIO_BASE_HPP_INCLUDED

  19. #define AUDIO_BASE_HPP_INCLUDED

  20. 

  21. #include "CarlaMathUtils.hpp"

  22. 

  23. extern "C" {

  24. #include "audio_decoder/ad.h"

  25. }

  26. 

  27. // #include "water/threads/ScopedLock.h"

  28. // #include "water/threads/SpinLock.h"

  29. 

  30. #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  31. # pragma GCC diagnostic push

  32. # pragma GCC diagnostic ignored "-Weffc++"

  33. #endif

  34. 

  35. #include "zita-resampler/resampler.h"

  36. 

  37. #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  38. # pragma GCC diagnostic pop

  39. #endif

  40. 

  41. #if defined(CARLA_OS_WIN)

  42. # include <windows.h>

  43. # define CARLA_MLOCK(ptr, size) VirtualLock((ptr), (size))

  44. #elif !defined(CARLA_OS_WASM)

  45. # include <sys/mman.h>

  46. # define CARLA_MLOCK(ptr, size) mlock((ptr), (size))

  47. #else

  48. # define CARLA_MLOCK(ptr, size)

  49. #endif

  50. 

  51. #define DEBUG_FILE_OPS

  52. 

  53. typedef struct adinfo ADInfo;

  54. 

  55. static inline

  56. bool carla_mlock(void* const ptr, const size_t size)

  57. {

  58.    #if defined(CARLA_OS_WASM)

  59.     // unsupported

  60.     return false;

  61.     (void)ptr; (void)size;

  62.    #elif defined(CARLA_OS_WIN)

  63.     return ::VirtualLock(ptr, size) != FALSE;

  64.    #else

  65.     return ::mlock(ptr, size) == 0;

  66.    #endif

  67. }

  68. 

  69. struct AudioMemoryPool {

  70.     float* buffer[2] = {};

  71. //     float*   tmpbuf[2];

  72.     uint32_t numFrames = 0;

  73. //     uint32_t maxFrame;

  74. //     volatile uint64_t startFrame;

  75.     CarlaMutex mutex;

  76. 

  77.     AudioMemoryPool() noexcept {}

  78. 

  79.     ~AudioMemoryPool() noexcept

  80.     {

  81.         destroy();

  82.     }

  83. 

  84.     void create(const uint32_t desiredNumFrames/*, const uint32_t fileNumFrames, const bool withTempBuffers*/)

  85.     {

  86.         CARLA_ASSERT(buffer[0] == nullptr);

  87.         CARLA_ASSERT(buffer[1] == nullptr);

  88. //         CARLA_ASSERT(tmpbuf[0] == nullptr);

  89. //         CARLA_ASSERT(tmpbuf[1] == nullptr);

  90. //         CARLA_ASSERT(startFrame == 0);

  91.         CARLA_ASSERT(numFrames == 0);

  92. //         CARLA_ASSERT(maxFrame == 0);

  93. 

  94.         buffer[0] = new float[desiredNumFrames];

  95.         buffer[1] = new float[desiredNumFrames];

  96. //         carla_zeroFloats(buffer[0], desiredNumFrames);

  97. //         carla_zeroFloats(buffer[1], desiredNumFrames);

  98.         CARLA_MLOCK(buffer[0], sizeof(float)*desiredNumFrames);

  99.         CARLA_MLOCK(buffer[1], sizeof(float)*desiredNumFrames);

  100. 

  101. //         if (withTempBuffers)

  102. //         {

  103. //             tmpbuf[0] = new float[desiredNumFrames];

  104. //             tmpbuf[1] = new float[desiredNumFrames];

  105. //             carla_zeroFloats(tmpbuf[0], desiredNumFrames);

  106. //             carla_zeroFloats(tmpbuf[1], desiredNumFrames);

  107. //             CARLA_MLOCK(tmpbuf[0], sizeof(float)*desiredNumFrames);

  108. //             CARLA_MLOCK(tmpbuf[1], sizeof(float)*desiredNumFrames);

  109. //         }

  110. //

  111. //         const water::GenericScopedLock<water::SpinLock> gsl(mutex);

  112. //

  113. //         startFrame = 0;

  114. //         numFrames = desiredNumFrames;

  115. //         maxFrame = fileNumFrames;

  116.     }

  117. 

  118.     void destroy() noexcept

  119.     {

  120.         {

  121.             const CarlaMutexLocker cml(mutex);

  122. //             startFrame = 0;

  123.             numFrames = 0;

  124. //             maxFrame = 0;

  125.         }

  126. 

  127.         if (buffer[0] != nullptr)

  128.         {

  129.             delete[] buffer[0];

  130.             buffer[0] = nullptr;

  131.         }

  132. 

  133.         if (buffer[1] != nullptr)

  134.         {

  135.             delete[] buffer[1];

  136.             buffer[1] = nullptr;

  137.         }

  138. 

  139. //         if (tmpbuf[0] != nullptr)

  140. //         {

  141. //             delete[] tmpbuf[0];

  142. //             tmpbuf[0] = nullptr;

  143. //         }

  144. //

  145. //         if (tmpbuf[1] != nullptr)

  146. //         {

  147. //             delete[] tmpbuf[1];

  148. //             tmpbuf[1] = nullptr;

  149. //         }

  150.     }

  151. 

  152. //     // NOTE it is assumed that mutex is locked

  153. //     bool tryPutData(float* const out1,

  154. //                     float* const out2,

  155. //                     uint64_t framePos,

  156. //                     const uint32_t frames,

  157. //                     const bool loopingMode,

  158. //                     const bool isOffline,

  159. //                     bool& needsRead,

  160. //                     uint64_t& needsReadFrame)

  161. //     {

  162. //         CARLA_SAFE_ASSERT_RETURN(numFrames != 0, false);

  163. //         CARLA_SAFE_ASSERT_RETURN(maxFrame != 0, false);

  164. //

  165. //         if (framePos >= maxFrame)

  166. //         {

  167. //             if (loopingMode)

  168. //                 framePos %= maxFrame;

  169. //             else

  170. //                 return false;

  171. //         }

  172. //

  173. //         uint64_t frameDiff;

  174. //         const uint32_t numFramesNearEnd = numFrames*3/4;

  175. //

  176. //         if (framePos < startFrame)

  177. //         {

  178. //             if (startFrame + numFrames <= maxFrame)

  179. //             {

  180. //                 needsRead = true;

  181. //                 needsReadFrame = framePos;

  182. //                 return false;

  183. //             }

  184. //

  185. //             frameDiff = framePos + (maxFrame - startFrame);

  186. //

  187. //             if (frameDiff + frames >= numFrames)

  188. //             {

  189. //                 needsRead = true;

  190. //                 needsReadFrame = framePos;

  191. //                 return false;

  192. //             }

  193. //

  194. //             carla_copyFloats(out1, buffer[0] + frameDiff, frames);

  195. //             carla_copyFloats(out2, buffer[1] + frameDiff, frames);

  196. //         }

  197. //         else

  198. //         {

  199. //             frameDiff = framePos - startFrame;

  200. //

  201. //             if (frameDiff + frames >= numFrames)

  202. //             {

  203. //                 needsRead = true;

  204. //                 needsReadFrame = framePos;

  205. //                 return false;

  206. //             }

  207. //

  208. //             carla_copyFloats(out1, buffer[0] + frameDiff, frames);

  209. //             carla_copyFloats(out2, buffer[1] + frameDiff, frames);

  210. //         }

  211. //

  212. //         if (frameDiff > numFramesNearEnd)

  213. //         {

  214. //             needsRead = true;

  215. //             needsReadFrame = framePos + (isOffline ? 0 : frames);

  216. //         }

  217. //

  218. //         return true;

  219. //     }

  220. 

  221.     CARLA_DECLARE_NON_COPYABLE(AudioMemoryPool)

  222. };

  223. 

  224. class AudioFileReader

  225. {

  226. public:

  227.     AudioFileReader()

  228. //         : fEntireFileLoaded(false),

  229. //           fLoopingMode(true),

  230. //           fNeedsFrame(0),

  231. //           fNeedsRead(false),

  232. //           fPollTempData(nullptr),

  233. //           fPollTempSize(0),

  234. //           fResampleTempData(nullptr),

  235. //           fResampleTempSize(0),

  236. //           fPool(),

  237. //           fPoolMutex(),

  238. //           fPoolReadyToSwap(false),

  239. //           fResampler(),

  240. //           fReaderMutex()

  241.     {

  242.         ad_clear_nfo(&fFileNfo);

  243.     }

  244. 

  245.     ~AudioFileReader()

  246.     {

  247.         destroy();

  248.     }

  249. 

  250.     void destroy()

  251.     {

  252.         const CarlaMutexLocker cml(fReaderMutex);

  253. 

  254.         cleanup();

  255. 

  256. //         fPool.destroy();

  257. //         fNeedsFrame = 0;

  258. //         fNeedsRead = false;

  259.     }

  260. 

  261. //     bool isEntireFileLoaded() const noexcept

  262. //     {

  263. //         return fEntireFileLoaded;

  264. //     }

  265. 

  266.     int getCurrentBitRate() const noexcept

  267.     {

  268.         return fCurrentBitRate;

  269.     }

  270. 

  271. //     uint32_t getMaxFrame() const noexcept

  272. //     {

  273. //         return fPool.maxFrame;

  274. //     }

  275. 

  276.     ADInfo getFileInfo() const noexcept

  277.     {

  278.         return fFileNfo;

  279.     }

  280. 

  281. //     void setLoopingMode(const bool on) noexcept

  282. //     {

  283. //         fLoopingMode = on;

  284. //     }

  285. 

  286. //     void setNeedsRead(const uint64_t frame) noexcept

  287. //     {

  288. //         if (fEntireFileLoaded)

  289. //             return;

  290. //

  291. //         fNeedsFrame = frame;

  292. //         fNeedsRead = true;

  293. //     }

  294. 

  295.     bool loadFilename(const char* const filename, const uint32_t sampleRate,

  296.                       const uint32_t previewDataSize, float* previewData)

  297.     {

  298.         CARLA_SAFE_ASSERT_RETURN(filename != nullptr && *filename != '\0', false);

  299. 

  300.         const CarlaMutexLocker cml(fReaderMutex);

  301. 

  302.         cleanup();

  303.         ad_clear_nfo(&fFileNfo);

  304. 

  305.         // open new

  306.         fFilePtr = ad_open(filename, &fFileNfo);

  307. 

  308.         if (fFilePtr == nullptr)

  309.             return false;

  310. 

  311.         ad_dump_nfo(99, &fFileNfo);

  312. 

  313.         // Fix misinformation from libsndfile

  314.         while (fFileNfo.frames % fFileNfo.channels)

  315.             --fFileNfo.frames;

  316. 

  317.         // invalid

  318.         if ((fFileNfo.channels != 1 && fFileNfo.channels != 2) || fFileNfo.frames <= 0)

  319.         {

  320.             if (fFileNfo.channels != 1 && fFileNfo.channels != 2)

  321.                 carla_stderr("loadFilename(\"%s\", ...) has not 1 or 2 channels", filename);

  322. 

  323.             if (fFileNfo.frames <= 0)

  324.                 carla_stderr("loadFilename(\"%s\", ...) has 0 frames", filename);

  325. 

  326.             ad_clear_nfo(&fFileNfo);

  327.             ad_close(fFilePtr);

  328.             fFilePtr = nullptr;

  329.             return false;

  330.         }

  331. 

  332.         const uint32_t numFrames = static_cast<uint32_t>(fFileNfo.frames);

  333.         const bool needsResample = fFileNfo.sample_rate != sampleRate;

  334.         uint32_t numResampledFrames;

  335. 

  336.         if (needsResample)

  337.         {

  338.             if (! fResampler.setup(fFileNfo.sample_rate, sampleRate, fFileNfo.channels, 32))

  339.             {

  340.                 ad_clear_nfo(&fFileNfo);

  341.                 ad_close(fFilePtr);

  342.                 fFilePtr = nullptr;

  343.                 carla_stderr2("loadFilename(\"%s\", ...) error, resampler setup failed");

  344.                 return false;

  345.             }

  346. 

  347.             fResampleRatio = static_cast<double>(sampleRate) / static_cast<double>(fFileNfo.sample_rate);

  348.             numResampledFrames = static_cast<uint32_t>(static_cast<double>(numFrames) * fResampleRatio + 0.5);

  349.         }

  350.         else

  351.         {

  352.             fResampler.clear();

  353.             fResampleRatio = 0.0;

  354.             numResampledFrames = numFrames;

  355.         }

  356. 

  357.         // read the first 30s of the file if seekable

  358.         const uint32_t initialFrames = fFileNfo.can_seek == 0

  359.                                      ? numFrames

  360.                                      : std::min(numFrames, fFileNfo.sample_rate * 600);

  361.         const uint32_t initialResampledFrames = fFileNfo.can_seek == 0

  362.                                               ? numResampledFrames

  363.                                               : std::min(numResampledFrames, sampleRate * 600);

  364.         fInitialMemoryPool.create(initialResampledFrames);

  365.         readIntoInitialMemoryPool(initialFrames, initialResampledFrames);

  366. 

  367. //         if (initialResampledFrames == numResampledFrames)

  368.         {

  369.             // file is no longer needed, we have it all in memory

  370.             ad_close(fFilePtr);

  371.             fFilePtr = nullptr;

  372. 

  373.             const float resampledFramesF = static_cast<float>(initialResampledFrames);

  374.             const float previewDataSizeF = static_cast<float>(previewDataSize);

  375.             for (uint i=0; i<previewDataSize; ++i)

  376.             {

  377.                 const float stepF = static_cast<float>(i)/previewDataSizeF * resampledFramesF;

  378.                 const uint step = carla_fixedValue(0U, initialResampledFrames-1U, static_cast<uint>(stepF + 0.5f));

  379.                 previewData[i] = std::max(std::fabs(fInitialMemoryPool.buffer[0][step]),

  380.                                           std::fabs(fInitialMemoryPool.buffer[1][step]));

  381.             }

  382. 

  383.             return true;

  384.         }

  385. 

  386.             // file is too big, do disk streaming as needed

  387. //                 const uint32_t poolNumFrames = sampleRate * 5;

  388. //                 const uint pollTempSize = poolNumFrames * fFileNfo.channels;

  389. //                 uint resampleTempSize = 0;

  390. //

  391. //                 readFilePreview(previewDataSize, previewData);

  392. //

  393. //                 fPool.create(poolNumFrames, maxFrame, true);

  394. //

  395. //                 try {

  396. //                     fPollTempData = new float[pollTempSize];

  397. //                 } catch (...) {

  398. //                     ad_clear_nfo(&fFileNfo);

  399. //                     ad_close(fFilePtr);

  400. //                     fFilePtr = nullptr;

  401. //                     carla_stderr2("loadFilename error, out of memory");

  402. //                     return false;

  403. //                 }

  404. //

  405. //                 CARLA_MLOCK(fPollTempData, sizeof(float)*pollTempSize);

  406. //

  407. //                 if (needsResample)

  408. //                 {

  409. //                     resampleTempSize = static_cast<uint32_t>(static_cast<double>(poolNumFrames) * fResampleRatio + 0.5);

  410. //                     resampleTempSize *= fFileNfo.channels;

  411. //

  412. //                     try {

  413. //                         fResampleTempData = new float[resampleTempSize];

  414. //                     } catch (...) {

  415. //                         delete[] fPollTempData;

  416. //                         fPollTempData = nullptr;

  417. //                         ad_clear_nfo(&fFileNfo);

  418. //                         ad_close(fFilePtr);

  419. //                         fFilePtr = nullptr;

  420. //                         carla_stderr2("loadFilename error, out of memory");

  421. //                         return false;

  422. //                     }

  423. //

  424. //                     CARLA_MLOCK(fResampleTempData, sizeof(float)*resampleTempSize);

  425. //                 }

  426. //

  427. //                 fPollTempSize = pollTempSize;

  428. //                 fResampleTempSize = resampleTempSize;

  429. 

  430. //             fNeedsRead = true;

  431.         return true;

  432.     }

  433. 

  434. //     void createSwapablePool(AudioFilePool& pool)

  435. //     {

  436. //         pool.create(fPool.numFrames, fPool.maxFrame, false);

  437. //     }

  438. 

  439. //     void putAndSwapAllData(AudioFilePool& pool)

  440. //     {

  441. //         const water::GenericScopedLock<water::SpinLock> gsl1(fPool.mutex);

  442. //         const water::GenericScopedLock<water::SpinLock> gsl2(pool.mutex);

  443. //         CARLA_SAFE_ASSERT_RETURN(fPool.numFrames != 0,);

  444. //         CARLA_SAFE_ASSERT_RETURN(fPool.buffer[0] != nullptr,);

  445. //         CARLA_SAFE_ASSERT_RETURN(fPool.tmpbuf[0] == nullptr,);

  446. //         CARLA_SAFE_ASSERT_RETURN(pool.numFrames == 0,);

  447. //         CARLA_SAFE_ASSERT_RETURN(pool.buffer[0] == nullptr,);

  448. //         CARLA_SAFE_ASSERT_RETURN(pool.tmpbuf[0] == nullptr,);

  449. //

  450. //         pool.startFrame = fPool.startFrame;

  451. //         pool.numFrames = fPool.numFrames;

  452. //         pool.buffer[0] = fPool.buffer[0];

  453. //         pool.buffer[1] = fPool.buffer[1];

  454. //

  455. //         fPool.startFrame = 0;

  456. //         fPool.numFrames = 0;

  457. //         fPool.buffer[0] = nullptr;

  458. //         fPool.buffer[1] = nullptr;

  459. //     }

  460. 

  461. //     bool tryPutData(AudioFilePool& pool,

  462. //                     float* const out1,

  463. //                     float* const out2,

  464. //                     uint64_t framePos,

  465. //                     const uint32_t frames,

  466. //                     const bool loopMode,

  467. //                     const bool isOffline,

  468. //                     bool& needsIdleRequest)

  469. //     {

  470. //         _tryPoolSwap(pool);

  471. //

  472. //         bool needsRead = false;

  473. //         uint64_t needsReadFrame;

  474. //         const bool ret = pool.tryPutData(out1, out2, framePos, frames, loopMode, isOffline, needsRead, needsReadFrame);

  475. //

  476. //         if (needsRead)

  477. //         {

  478. //             needsIdleRequest = true;

  479. //             setNeedsRead(needsReadFrame);

  480. //         }

  481. //

  482. // #ifdef DEBUG_FILE_OPS

  483. //         if (! ret) {

  484. //             carla_stdout("tryPutData fail");

  485. //         }

  486. // #endif

  487. //         return ret;

  488. //     }

  489. 

  490.     float tickFrames(float* const buffers[],

  491.                      const uint32_t bufferOffset,

  492.                      const uint32_t frames,

  493.                      uint64_t framePos,

  494.                      const bool loopingMode, const bool isOffline)

  495.     {

  496.         float* const out1 = buffers[0] + bufferOffset;

  497.         float* const out2 = buffers[1] + bufferOffset;

  498.         float* const playCV = buffers[2] + bufferOffset;

  499. 

  500.         // entire file in memory, use memory pool directly

  501.         if (true)

  502.         {

  503.             uint32_t framesAvailable, numPoolFrames;

  504. 

  505.             {

  506.                 const CarlaMutexTryLocker cmtl(fInitialMemoryPool.mutex, isOffline);

  507. 

  508.                 numPoolFrames = fInitialMemoryPool.numFrames;

  509. 

  510.                 if (numPoolFrames == 0 || ! cmtl.wasLocked())

  511.                 {

  512.                     carla_zeroFloats(out1, frames);

  513.                     carla_zeroFloats(out2, frames);

  514.                     carla_zeroFloats(playCV, frames);

  515.                     return 0.f;

  516.                 }

  517. 

  518.                 if (loopingMode && framePos >= numPoolFrames)

  519.                     framePos %= numPoolFrames;

  520. 

  521.                 if (framePos >= numPoolFrames)

  522.                 {

  523.                     carla_zeroFloats(out1, frames);

  524.                     carla_zeroFloats(out2, frames);

  525.                     carla_zeroFloats(playCV, frames);

  526.                     return 0.f;

  527.                 }

  528. 

  529.                 framesAvailable = std::min(frames, numPoolFrames - static_cast<uint32_t>(framePos));

  530. 

  531.                 carla_copyFloats(out1, fInitialMemoryPool.buffer[0] + framePos, framesAvailable);

  532.                 carla_copyFloats(out2, fInitialMemoryPool.buffer[1] + framePos, framesAvailable);

  533.                 carla_fillFloatsWithSingleValue(playCV, 10.f, framesAvailable);

  534.             }

  535. 

  536.             if (frames != framesAvailable)

  537.             {

  538.                 tickFrames(buffers,

  539.                            bufferOffset + framesAvailable,

  540.                            frames - framesAvailable,

  541.                            framePos + framesAvailable,

  542.                            loopingMode, isOffline);

  543.             }

  544. 

  545.             return static_cast<float>(framePos) / static_cast<float>(numPoolFrames);

  546.         }

  547. 

  548.         return 0.f;

  549.     }

  550. 

  551. //     void readFilePreview(uint32_t previewDataSize, float* previewData)

  552. //     {

  553. //         carla_zeroFloats(previewData, previewDataSize);

  554. //

  555. //         const uint fileNumFrames = static_cast<uint>(fFileNfo.frames);

  556. //         const float fileNumFramesF = static_cast<float>(fileNumFrames);

  557. //         const float previewDataSizeF = static_cast<float>(previewDataSize);

  558. //         const uint samplesPerRun = fFileNfo.channels;

  559. //         const uint maxSampleToRead = fileNumFrames - samplesPerRun;

  560. //         CARLA_SAFE_ASSERT_INT_RETURN(samplesPerRun == 1 || samplesPerRun == 2, samplesPerRun,);

  561. //         float tmp[2] = { 0.0f, 0.0f };

  562. //

  563. //         if (samplesPerRun == 2)

  564. //             previewDataSize -= 1;

  565. //

  566. //         for (uint i=0; i<previewDataSize; ++i)

  567. //         {

  568. //             const float posF = static_cast<float>(i)/previewDataSizeF * fileNumFramesF;

  569. //             const uint pos = carla_fixedValue(0U, maxSampleToRead, static_cast<uint>(posF));

  570. //

  571. //             ad_seek(fFilePtr, pos);

  572. //             ad_read(fFilePtr, tmp, samplesPerRun);

  573. //             previewData[i] = std::max(std::fabs(tmp[0]), std::fabs(tmp[1]));

  574. //         }

  575. //     }

  576. 

  577. //     void readPoll()

  578. //     {

  579. //         const CarlaMutexLocker cml(fReaderMutex);

  580. //

  581. //         if (fFileNfo.channels == 0 || fFilePtr == nullptr)

  582. //         {

  583. //             carla_debug("R: no song loaded");

  584. //             fNeedsFrame = 0;

  585. //             fNeedsRead = false;

  586. //             return;

  587. //         }

  588. //         if (fPollTempData == nullptr)

  589. //         {

  590. //             carla_debug("R: nothing to poll");

  591. //             fNeedsFrame = 0;

  592. //             fNeedsRead = false;

  593. //             return;

  594. //         }

  595. //

  596. //         const uint32_t maxFrame = fPool.maxFrame;

  597. //         uint64_t lastFrame = fNeedsFrame;

  598. //         int64_t readFrameCheck;

  599. //

  600. //         if (lastFrame >= maxFrame)

  601. //         {

  602. //             if (fLoopingMode)

  603. //             {

  604. //                 const uint64_t readFrameCheckLoop = lastFrame % maxFrame;

  605. //                 CARLA_SAFE_ASSERT_RETURN(readFrameCheckLoop < INT32_MAX,);

  606. //

  607. //                 carla_debug("R: transport out of bounds for loop");

  608. //                 readFrameCheck = static_cast<int64_t>(readFrameCheckLoop);

  609. //             }

  610. //             else

  611. //             {

  612. //                 carla_debug("R: transport out of bounds");

  613. //                 fNeedsFrame = 0;

  614. //                 fNeedsRead = false;

  615. //                 return;

  616. //             }

  617. //         }

  618. //         else

  619. //         {

  620. //             CARLA_SAFE_ASSERT_RETURN(lastFrame < INT32_MAX,);

  621. //             readFrameCheck = static_cast<int64_t>(lastFrame);

  622. //         }

  623. //

  624. //         const int64_t readFrame = readFrameCheck;

  625. //

  626. //         // temp data buffer

  627. //         carla_zeroFloats(fPollTempData, fPollTempSize);

  628. //

  629. //         {

  630. // #if 0

  631. //             const int32_t sampleRate = 44100;

  632. //             carla_debug("R: poll data - reading at frame %li, time %li:%02li, lastFrame %li",

  633. //                         readFrame, readFrame/sampleRate/60, (readFrame/sampleRate) % 60, lastFrame);

  634. // #endif

  635. //

  636. //             const int64_t readFrameReal = carla_isNotZero(fResampleRatio)

  637. //                                         ? static_cast<int64_t>(static_cast<double>(readFrame) / fResampleRatio + 0.5)

  638. //                                         : readFrame;

  639. //

  640. //             ad_seek(fFilePtr, readFrameReal);

  641. //             size_t i = 0;

  642. //             ssize_t j = 0;

  643. //             ssize_t rv = ad_read(fFilePtr, fPollTempData, fPollTempSize);

  644. //

  645. //             if (rv < 0)

  646. //             {

  647. //                 carla_stderr("R: ad_read1 failed");

  648. //                 fNeedsFrame = 0;

  649. //                 fNeedsRead = false;

  650. //                 return;

  651. //             }

  652. //

  653. //             const size_t urv = static_cast<size_t>(rv);

  654. //

  655. //             // see if we can read more

  656. //             if (readFrameReal + rv >= static_cast<ssize_t>(fFileNfo.frames) && urv < fPollTempSize)

  657. //             {

  658. // #ifdef DEBUG_FILE_OPS

  659. //                 carla_stdout("R: from start");

  660. // #endif

  661. //                 ad_seek(fFilePtr, 0);

  662. //                 j = ad_read(fFilePtr, fPollTempData+urv, fPollTempSize-urv);

  663. //

  664. //                 if (j < 0)

  665. //                 {

  666. //                     carla_stderr("R: ad_read2 failed");

  667. //                     fNeedsFrame = 0;

  668. //                     fNeedsRead = false;

  669. //                     return;

  670. //                 }

  671. //

  672. //                 rv += j;

  673. //             }

  674. //

  675. // #ifdef DEBUG_FILE_OPS

  676. //             carla_stdout("R: reading %li frames at frame %lu", rv, readFrameCheck);

  677. // #endif

  678. //             fCurrentBitRate = ad_get_bitrate(fFilePtr);

  679. //

  680. //             // local copy

  681. //             const uint32_t poolNumFrames = fPool.numFrames;

  682. //             float* const pbuffer0 = fPool.tmpbuf[0];

  683. //             float* const pbuffer1 = fPool.tmpbuf[1];

  684. //             const float* tmpbuf = fPollTempData;

  685. //

  686. //             // resample as needed

  687. //             if (fResampleTempSize != 0)

  688. //             {

  689. //                 tmpbuf = fResampleTempData;

  690. //                 fResampler.inp_count = static_cast<uint>(rv / fFileNfo.channels);

  691. //                 fResampler.out_count = fResampleTempSize / fFileNfo.channels;

  692. //                 fResampler.inp_data = fPollTempData;

  693. //                 fResampler.out_data = fResampleTempData;

  694. //                 fResampler.process();

  695. //                 CARLA_ASSERT_INT(fResampler.inp_count <= 1, fResampler.inp_count);

  696. //             }

  697. //

  698. //             j = 0;

  699. //             do {

  700. //                 if (fFileNfo.channels == 1)

  701. //                 {

  702. //                     for (; i < poolNumFrames && j < rv; ++i, ++j)

  703. //                         pbuffer0[i] = pbuffer1[i] = tmpbuf[j];

  704. //                 }

  705. //                 else

  706. //                 {

  707. //                     for (; i < poolNumFrames && j < rv; ++j)

  708. //                     {

  709. //                         if (j % 2 == 0)

  710. //                         {

  711. //                             pbuffer0[i] = tmpbuf[j];

  712. //                         }

  713. //                         else

  714. //                         {

  715. //                             pbuffer1[i] = tmpbuf[j];

  716. //                             ++i;

  717. //                         }

  718. //                     }

  719. //                 }

  720. //

  721. //                 if (i >= poolNumFrames)

  722. //                     break;

  723. //

  724. //                 if (rv == fFileNfo.frames)

  725. //                 {

  726. //                     // full file read

  727. //                     j = 0;

  728. // #ifdef DEBUG_FILE_OPS

  729. //                     carla_stdout("R: full file was read, filling buffers again");

  730. // #endif

  731. //                 }

  732. //                 else

  733. //                 {

  734. // #ifdef DEBUG_FILE_OPS

  735. //                     carla_stdout("read break, not enough space");

  736. // #endif

  737. //                     carla_zeroFloats(pbuffer0, poolNumFrames - i);

  738. //                     carla_zeroFloats(pbuffer1, poolNumFrames - i);

  739. //                     break;

  740. //                 }

  741. //

  742. //             } while (i < poolNumFrames);

  743. //

  744. //             // lock, and put data asap

  745. //             const CarlaMutexLocker cmlp(fPoolMutex);

  746. //             const water::GenericScopedLock<water::SpinLock> gsl(fPool.mutex);

  747. //

  748. //             std::memcpy(fPool.buffer[0], pbuffer0, sizeof(float)*poolNumFrames);

  749. //             std::memcpy(fPool.buffer[1], pbuffer1, sizeof(float)*poolNumFrames);

  750. //             fPool.startFrame = static_cast<uint64_t>(readFrame);

  751. //             fPoolReadyToSwap = true;

  752. // #ifdef DEBUG_FILE_OPS

  753. //             carla_stdout("Reading done and internal pool is now full");

  754. // #endif

  755. //         }

  756. //

  757. //         fNeedsRead = false;

  758. //     }

  759. 

  760. private:

  761. //     bool fEntireFileLoaded;

  762. //     bool fLoopingMode;

  763.     int fCurrentBitRate = 0;

  764. //     volatile uint64_t fNeedsFrame;

  765. //     volatile bool fNeedsRead;

  766. 

  767.     void*  fFilePtr = nullptr;

  768.     ADInfo fFileNfo = {};

  769. 

  770. //     float* fPollTempData;

  771. //     uint fPollTempSize;

  772. 

  773.     double fResampleRatio = 0.0;

  774. //     float* fResampleTempData;

  775. //     uint fResampleTempSize;

  776. 

  777.     AudioMemoryPool fInitialMemoryPool;

  778. //     CarlaMutex    fPoolMutex;

  779. //     bool          fPoolReadyToSwap;

  780.     Resampler     fResampler;

  781.     CarlaMutex    fReaderMutex;

  782. 

  783.     // assumes reader lock is active

  784.     void cleanup()

  785.     {

  786.         fCurrentBitRate = 0;

  787. //         fEntireFileLoaded = false;

  788.         fInitialMemoryPool.destroy();

  789. 

  790.         if (fFilePtr != nullptr)

  791.         {

  792.             ad_close(fFilePtr);

  793.             fFilePtr = nullptr;

  794.         }

  795. 

  796. //         if (fPollTempData != nullptr)

  797. //         {

  798. //             delete[] fPollTempData;

  799. //             fPollTempData = nullptr;

  800. //             fPollTempSize = 0;

  801. //         }

  802. //

  803. //         if (fResampleTempData != nullptr)

  804. //         {

  805. //             delete[] fResampleTempData;

  806. //             fResampleTempData = nullptr;

  807. //             fResampleTempSize = 0;

  808. //         }

  809.     }

  810. 

  811.     void readIntoInitialMemoryPool(const uint numFrames, const uint numResampledFrames)

  812.     {

  813.         const uint channels = fFileNfo.channels;

  814.         const uint fileBufferSize = numFrames * channels;

  815. 

  816.         float* const fileBuffer = (float*)std::malloc(fileBufferSize * sizeof(float));

  817.         CARLA_SAFE_ASSERT_RETURN(fileBuffer != nullptr,);

  818. 

  819.         ad_seek(fFilePtr, 0);

  820.         ssize_t rv = ad_read(fFilePtr, fileBuffer, fileBufferSize);

  821.         CARLA_SAFE_ASSERT_INT2_RETURN(rv == static_cast<ssize_t>(fileBufferSize),

  822.                                       rv, fileBufferSize,

  823.                                       std::free(fileBuffer));

  824. 

  825.         fCurrentBitRate = ad_get_bitrate(fFilePtr);

  826. 

  827.         float* resampledBuffer;

  828. 

  829.         if (numFrames != numResampledFrames)

  830.         {

  831.             const uint resampledBufferSize = numResampledFrames * channels;

  832.             resampledBuffer = (float*)std::malloc(resampledBufferSize * sizeof(float));

  833.             CARLA_SAFE_ASSERT_RETURN(resampledBuffer != nullptr, std::free(fileBuffer););

  834. 

  835.             fResampler.inp_count = numFrames;

  836.             fResampler.out_count = resampledBufferSize;

  837.             fResampler.inp_data = fileBuffer;

  838.             fResampler.out_data = resampledBuffer;

  839.             fResampler.process();

  840.             CARLA_SAFE_ASSERT_UINT(fResampler.out_count == 0, fResampler.out_count);

  841. 

  842.             rv = static_cast<ssize_t>(resampledBufferSize - fResampler.out_count);

  843.         }

  844.         else

  845.         {

  846.             resampledBuffer = fileBuffer;

  847.         }

  848. 

  849.         {

  850.             // lock, and put data asap

  851.             const CarlaMutexLocker cml(fInitialMemoryPool.mutex);

  852. 

  853.             if (channels == 1)

  854.             {

  855.                 for (ssize_t i=0; i < rv; ++i)

  856.                     fInitialMemoryPool.buffer[0][i] = fInitialMemoryPool.buffer[1][i] = resampledBuffer[i];

  857.             }

  858.             else

  859.             {

  860.                 for (ssize_t i=0, j=0; i < rv; ++j)

  861.                 {

  862.                     fInitialMemoryPool.buffer[0][j] = resampledBuffer[i++];

  863.                     fInitialMemoryPool.buffer[1][j] = resampledBuffer[i++];

  864.                 }

  865.             }

  866. 

  867.             fInitialMemoryPool.numFrames = numResampledFrames;

  868.         }

  869. 

  870.         if (resampledBuffer != fileBuffer)

  871.             std::free(resampledBuffer);

  872. 

  873.         std::free(fileBuffer);

  874. 

  875. //         fEntireFileLoaded = true;

  876.     }

  877. 

  878.     // try a pool data swap if possible and relevant

  879.     // NOTE it is assumed that `pool` mutex is locked

  880. //     void _tryPoolSwap(AudioFilePool& pool)

  881. //     {

  882. //         uint32_t tmp_u32;

  883. //         uint64_t tmp_u64;

  884. //         float* tmp_fp;

  885. //

  886. //         const CarlaMutexTryLocker cmtl(fPoolMutex);

  887. //

  888. //         if (! cmtl.wasLocked())

  889. //             return;

  890. //

  891. //         const water::GenericScopedLock<water::SpinLock> gsl(fPool.mutex);

  892. //

  893. //         if (! fPoolReadyToSwap)

  894. //             return;

  895. //

  896. //         tmp_u64 = pool.startFrame;

  897. //         pool.startFrame = fPool.startFrame;

  898. //         fPool.startFrame = tmp_u64;

  899. //

  900. //         tmp_u32 = pool.numFrames;

  901. //         pool.numFrames = fPool.numFrames;

  902. //         fPool.numFrames = tmp_u32;

  903. //

  904. //         tmp_fp = pool.buffer[0];

  905. //         pool.buffer[0] = fPool.buffer[0];

  906. //         fPool.buffer[0] = tmp_fp;

  907. //

  908. //         tmp_fp = pool.buffer[1];

  909. //         pool.buffer[1] = fPool.buffer[1];

  910. //         fPool.buffer[1] = tmp_fp;

  911. //

  912. //         fPoolReadyToSwap = false;

  913. //

  914. // #ifdef DEBUG_FILE_OPS

  915. //         carla_stdout("Pools have been swapped, internal one is now invalidated");

  916. // #endif

  917. //     }

  918. 

  919.     CARLA_DECLARE_NON_COPYABLE(AudioFileReader)

  920. };

  921. 

  922. #endif // AUDIO_BASE_HPP_INCLUDED