fix: std memory ordeal

michalsek · michalsek · commit a132957d0de6 · 2025-12-03T19:29:15.000+01:00
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -114,7 +114,7 @@ ReturnStatus<std::string> AndroidAudioRecorder::start() {
 
   jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->start(); });
 
-  state_.store(RecorderState::Recording);
+  state_.store(RecorderState::Recording, std::memory_order_release);
   return ReturnStatus<std::string>::Success(std::format("file://{}", filePath_));
 }
 
@@ -136,7 +136,7 @@ ReturnStatus<std::tuple<std::string, double, double>> AndroidAudioRecorder::stop
         "Audio stream is not initialized.");
   }
 
-  state_.store(RecorderState::Idle);
+  state_.store(RecorderState::Idle, std::memory_order_release);
   jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });
   mStream_->requestStop();
 
@@ -183,13 +183,13 @@ ReturnStatus<std::string> AndroidAudioRecorder::enableFileOutput(
     filePath_ = fileResult.getValue();
   }
 
-  fileOutputEnabled_.store(true);
+  fileOutputEnabled_.store(true, std::memory_order_release);
   return ReturnStatus<std::string>::Success(filePath_);
 }
 
 void AndroidAudioRecorder::disableFileOutput() {
   Locker fileWriterLock(fileWriterMutex_);
-  fileOutputEnabled_.store(false);
+  fileOutputEnabled_.store(false, std::memory_order_release);
   fileWriter_ = nullptr;
 }
 
@@ -199,7 +199,7 @@ void AndroidAudioRecorder::pause() {
   }
 
   mStream_->pause(0);
-  state_.store(RecorderState::Paused);
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
 void AndroidAudioRecorder::resume() {
@@ -208,7 +208,7 @@ void AndroidAudioRecorder::resume() {
   }
 
   mStream_->start(0);
-  state_.store(RecorderState::Recording);
+  state_.store(RecorderState::Recording, std::memory_order_release);
 }
 
 ReturnStatus<void> AndroidAudioRecorder::setOnAudioReadyCallback(
@@ -224,14 +224,14 @@ ReturnStatus<void> AndroidAudioRecorder::setOnAudioReadyCallback(
     callback_->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
-  callbackOutputEnabled_.store(true);
+  callbackOutputEnabled_.store(true, std::memory_order_release);
 
   return ReturnStatus<void>::Success();
 }
 
 void AndroidAudioRecorder::clearOnAudioReadyCallback() {
   Locker callbackLock(callbackMutex_);
-  callbackOutputEnabled_.store(false);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
   callback_ = nullptr;
 }
 
@@ -275,20 +275,20 @@ double AndroidAudioRecorder::getCurrentDuration() const {
 }
 
 bool AndroidAudioRecorder::isRecording() const {
-  return state_.load() == RecorderState::Recording &&
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
       mStream_->getState() == oboe::StreamState::Started;
 }
 
 bool AndroidAudioRecorder::isPaused() const {
-  return state_.load() == RecorderState::Paused;
+  return state_.load(std::memory_order_acquire) == RecorderState::Paused;
 }
 
 bool AndroidAudioRecorder::isIdle() const {
-  return state_.load() == RecorderState::Idle;
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
 }
 
 void AndroidAudioRecorder::cleanup() {
-  state_.store(RecorderState::Idle);
+  state_.store(RecorderState::Idle, std::memory_order_release);
 
   if (mStream_) {
     mStream_->close();
@@ -308,7 +308,7 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
     }
 
     mStream_->requestStart();
-    state_.store(RecorderState::Recording);
+    state_.store(RecorderState::Recording, std::memory_order_release);
   }
 }
 
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp
@@ -81,8 +81,9 @@ OpenFileStatus MiniAudioFileWriter::openFile(
 
   isConverterRequired_.store(
       (streamSampleRate_ != properties_->sampleRate) ||
-      (streamChannelCount_ != properties_->channelCount) ||
-      (getDataFormat(properties_) != ma_format_f32));
+          (streamChannelCount_ != properties_->channelCount) ||
+          (getDataFormat(properties_) != ma_format_f32),
+      std::memory_order_release);
 
   result = initializeConverterIfNeeded();
 
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
@@ -21,7 +21,7 @@
     while (processedFrames < numFrames) {
       int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
 
-      if (isRunning_.load()) {
+      if (isRunning_.load(std::memory_order_acquire)) {
         renderAudio_(audioBus_, framesToProcess);
       } else {
         audioBus_->zero();
@@ -57,13 +57,13 @@
   }
 
   bool success = [audioPlayer_ start];
-  isRunning_.store(success);
+  isRunning_.store(success, std::memory_order_release);
   return success;
 }
 
 void IOSAudioPlayer::stop()
 {
-  isRunning_.store(false);
+  isRunning_.store(false, std::memory_order_release);
   [audioPlayer_ stop];
 }
 
@@ -74,21 +74,22 @@
   }
 
   bool success = [audioPlayer_ resume];
-  isRunning_.store(success);
+  isRunning_.store(success, std::memory_order_release);
   return success;
 }
 
 void IOSAudioPlayer::suspend()
 {
-  isRunning_.store(false);
+  isRunning_.store(false, std::memory_order_release);
   [audioPlayer_ suspend];
 }
 
 bool IOSAudioPlayer::isRunning() const
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
 
-  return isRunning_.load() && [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
+  return isRunning_.load(std::memory_order_acquire) &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
 }
 
 void IOSAudioPlayer::cleanup()
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
@@ -117,7 +117,7 @@
   }
 
   [nativeRecorder_ start];
-  state_.store(RecorderState::Recording);
+  state_.store(RecorderState::Recording, std::memory_order_release);
   return ReturnStatus<std::string>::Success(filePath_);
 }
 
@@ -134,7 +134,7 @@
     return ReturnStatus<std::tuple<std::string, double, double>>::Error("Not recording");
   }
 
-  state_.store(RecorderState::Idle);
+  state_.store(RecorderState::Idle, std::memory_order_release);
   [nativeRecorder_ stop];
 
   if (usesFileOutput()) {
@@ -177,18 +177,18 @@
   }
 
   // TODO: atomic szpont?
-  if (errorCallbackId_.load() != 0) {
-    fileWriter_->setOnErrorCallback(errorCallbackId_.load());
+  if (errorCallbackId_.load(std::memory_order_acquire) != 0) {
+    fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
   }
 
-  fileOutputEnabled_.store(true);
+  fileOutputEnabled_.store(true, std::memory_order_release);
   return ReturnStatus<std::string>::Success(filePath_);
 }
 
 void IOSAudioRecorder::disableFileOutput()
 {
   Locker lock(fileWriterMutex_);
-  fileOutputEnabled_.store(false);
+  fileOutputEnabled_.store(false, std::memory_order_release);
   fileWriter_ = nullptr;
 }
 
@@ -202,14 +202,14 @@
         [nativeRecorder_ getBufferSize], [nativeRecorder_ getInputFormat].channelCount);
   }
 
-  isConnected_.store(true);
+  isConnected_.store(true, std::memory_order_release);
 }
 
 void IOSAudioRecorder::disconnect()
 {
   Locker lock(adapterNodeMutex_);
   adapterNode_ = nullptr;
-  isConnected_.store(false);
+  isConnected_.store(false, std::memory_order_release);
 }
 
 void IOSAudioRecorder::pause()
@@ -219,7 +219,7 @@
   }
 
   [nativeRecorder_ pause];
-  state_.store(RecorderState::Paused);
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
 void IOSAudioRecorder::resume()
@@ -229,20 +229,20 @@
   }
 
   [nativeRecorder_ resume];
-  state_.store(RecorderState::Recording);
+  state_.store(RecorderState::Recording, std::memory_order_release);
 }
 
 bool IOSAudioRecorder::isRecording() const
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  return state_.load() == RecorderState::Recording &&
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
       [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
 }
 
 bool IOSAudioRecorder::isPaused() const
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  auto currentState = state_.load();
+  auto currentState = state_.load(std::memory_order_acquire);
 
   if (currentState == RecorderState::Idle) {
     return false;
@@ -254,7 +254,7 @@
 
 bool IOSAudioRecorder::isIdle() const
 {
-  return state_.load() == RecorderState::Idle;
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
 }
 
 ReturnStatus<void> IOSAudioRecorder::setOnAudioReadyCallback(
@@ -277,18 +277,19 @@
     }
   }
 
-  if (errorCallbackId_.load() != 0) {
-    callback_->setOnErrorCallback(errorCallbackId_.load());
+  // TODO: atomic szpont?
+  if (errorCallbackId_.load(std::memory_order_acquire) != 0) {
+    callback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
   }
 
-  callbackOutputEnabled_.store(true);
+  callbackOutputEnabled_.store(true, std::memory_order_release);
   return ReturnStatus<void>::Success();
 }
 
 void IOSAudioRecorder::clearOnAudioReadyCallback()
 {
   Locker lock(callbackMutex_);
-  callbackOutputEnabled_.store(false);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
   callback_ = nullptr;
 }
 
@@ -301,12 +302,12 @@
   if (usesCallback()) {
     callback_->setOnErrorCallback(callbackId);
   }
-  errorCallbackId_.store(callbackId);
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
 void IOSAudioRecorder::clearOnErrorCallback()
 {
-  errorCallbackId_.store(0);
+  errorCallbackId_.store(0, std::memory_order_release);
 
   if (usesFileOutput()) {
     fileWriter_->clearOnErrorCallback();
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.mm
@@ -120,7 +120,7 @@
     }
 
     fileURL_ = nil;
-    framesWritten_.store(0);
+    framesWritten_.store(0, std::memory_order_release);
 
     return ReturnStatus<std::tuple<double, double>>::Success(
         std::make_tuple(fileDuration, fileSizeBytesMb));
@@ -224,7 +224,7 @@
 
 void FileWriter::setOnErrorCallback(uint64_t callbackId)
 {
-  errorCallbackId_.store(callbackId);
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
 void FileWriter::clearOnErrorCallback()
@@ -234,7 +234,7 @@
 
 void FileWriter::invokeOnErrorCallback(const std::string &message)
 {
-  uint64_t callbackId = errorCallbackId_.load();
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
 
   // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
   // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.mm
@@ -34,12 +34,12 @@
     circularBus_[i] = busAudioArray;
   }
 
-  isInitialized_.store(true);
+  isInitialized_.store(true, std::memory_order_release);
 }
 
 RecorderCallback::~RecorderCallback()
 {
-  isInitialized_.store(false);
+  isInitialized_.store(false, std::memory_order_release);
   @autoreleasepool {
     converter_ = nil;
     bufferFormat_ = nil;
@@ -114,7 +114,7 @@
 
 void RecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
 {
-  if (!isInitialized_.load()) {
+  if (!isInitialized_.load(std::memory_order_acquire)) {
     return;
   }
 
@@ -222,17 +222,17 @@
 
 void RecorderCallback::setOnErrorCallback(uint64_t callbackId)
 {
-  errorCallbackId_.store(callbackId);
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
 void RecorderCallback::clearOnErrorCallback()
 {
-  errorCallbackId_.store(0);
+  errorCallbackId_.store(0, std::memory_order_release);
 }
 
 void RecorderCallback::invokeOnErrorCallback(const std::string &message)
 {
-  uint64_t callbackId = errorCallbackId_.load();
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
 
   // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
   // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ ReturnStatus<std::string> AndroidAudioRecorder::start() {`
`114`	`114`
`115`	`115`	`jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->start(); });`
`116`	`116`
`117`		`- state_.store(RecorderState::Recording);`
	`117`	`+ state_.store(RecorderState::Recording, std::memory_order_release);`
`118`	`118`	`return ReturnStatus<std::string>::Success(std::format("file://{}", filePath_));`
`119`	`119`	`}`
`120`	`120`
`@@ -136,7 +136,7 @@ ReturnStatus<std::tuple<std::string, double, double>> AndroidAudioRecorder::stop`
`136`	`136`	`"Audio stream is not initialized.");`
`137`	`137`	`}`
`138`	`138`
`139`		`- state_.store(RecorderState::Idle);`
	`139`	`+ state_.store(RecorderState::Idle, std::memory_order_release);`
`140`	`140`	`jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });`
`141`	`141`	`mStream_->requestStop();`
`142`	`142`
`@@ -183,13 +183,13 @@ ReturnStatus<std::string> AndroidAudioRecorder::enableFileOutput(`
`183`	`183`	`filePath_ = fileResult.getValue();`
`184`	`184`	`}`
`185`	`185`
`186`		`- fileOutputEnabled_.store(true);`
	`186`	`+ fileOutputEnabled_.store(true, std::memory_order_release);`
`187`	`187`	`return ReturnStatus<std::string>::Success(filePath_);`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`void AndroidAudioRecorder::disableFileOutput() {`
`191`	`191`	`Locker fileWriterLock(fileWriterMutex_);`
`192`		`- fileOutputEnabled_.store(false);`
	`192`	`+ fileOutputEnabled_.store(false, std::memory_order_release);`
`193`	`193`	`fileWriter_ = nullptr;`
`194`	`194`	`}`
`195`	`195`
`@@ -199,7 +199,7 @@ void AndroidAudioRecorder::pause() {`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`mStream_->pause(0);`
`202`		`- state_.store(RecorderState::Paused);`
	`202`	`+ state_.store(RecorderState::Paused, std::memory_order_release);`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`void AndroidAudioRecorder::resume() {`
`@@ -208,7 +208,7 @@ void AndroidAudioRecorder::resume() {`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`mStream_->start(0);`
`211`		`- state_.store(RecorderState::Recording);`
	`211`	`+ state_.store(RecorderState::Recording, std::memory_order_release);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`ReturnStatus<void> AndroidAudioRecorder::setOnAudioReadyCallback(`
`@@ -224,14 +224,14 @@ ReturnStatus<void> AndroidAudioRecorder::setOnAudioReadyCallback(`
`224`	`224`	`callback_->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);`
`225`	`225`	`}`
`226`	`226`
`227`		`- callbackOutputEnabled_.store(true);`
	`227`	`+ callbackOutputEnabled_.store(true, std::memory_order_release);`
`228`	`228`
`229`	`229`	`return ReturnStatus<void>::Success();`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`void AndroidAudioRecorder::clearOnAudioReadyCallback() {`
`233`	`233`	`Locker callbackLock(callbackMutex_);`
`234`		`- callbackOutputEnabled_.store(false);`
	`234`	`+ callbackOutputEnabled_.store(false, std::memory_order_release);`
`235`	`235`	`callback_ = nullptr;`
`236`	`236`	`}`
`237`	`237`
`@@ -275,20 +275,20 @@ double AndroidAudioRecorder::getCurrentDuration() const {`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`bool AndroidAudioRecorder::isRecording() const {`
`278`		`- return state_.load() == RecorderState::Recording &&`
	`278`	`+ return state_.load(std::memory_order_acquire) == RecorderState::Recording &&`
`279`	`279`	`mStream_->getState() == oboe::StreamState::Started;`
`280`	`280`	`}`
`281`	`281`
`282`	`282`	`bool AndroidAudioRecorder::isPaused() const {`
`283`		`- return state_.load() == RecorderState::Paused;`
	`283`	`+ return state_.load(std::memory_order_acquire) == RecorderState::Paused;`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`bool AndroidAudioRecorder::isIdle() const {`
`287`		`- return state_.load() == RecorderState::Idle;`
	`287`	`+ return state_.load(std::memory_order_acquire) == RecorderState::Idle;`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`void AndroidAudioRecorder::cleanup() {`
`291`		`- state_.store(RecorderState::Idle);`
	`291`	`+ state_.store(RecorderState::Idle, std::memory_order_release);`
`292`	`292`
`293`	`293`	`if (mStream_) {`
`294`	`294`	`mStream_->close();`
`@@ -308,7 +308,7 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`mStream_->requestStart();`
`311`		`- state_.store(RecorderState::Recording);`
	`311`	`+ state_.store(RecorderState::Recording, std::memory_order_release);`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`while (processedFrames < numFrames) {`
`22`	`22`	`int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);`
`23`	`23`
`24`		`- if (isRunning_.load()) {`
	`24`	`+ if (isRunning_.load(std::memory_order_acquire)) {`
`25`	`25`	`renderAudio_(audioBus_, framesToProcess);`
`26`	`26`	`} else {`
`27`	`27`	`audioBus_->zero();`
`@@ -57,13 +57,13 @@`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`bool success = [audioPlayer_ start];`
`60`		`- isRunning_.store(success);`
	`60`	`+ isRunning_.store(success, std::memory_order_release);`
`61`	`61`	`return success;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`void IOSAudioPlayer::stop()`
`65`	`65`	`{`
`66`		`- isRunning_.store(false);`
	`66`	`+ isRunning_.store(false, std::memory_order_release);`
`67`	`67`	`[audioPlayer_ stop];`
`68`	`68`	`}`
`69`	`69`
`@@ -74,21 +74,22 @@`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`bool success = [audioPlayer_ resume];`
`77`		`- isRunning_.store(success);`
	`77`	`+ isRunning_.store(success, std::memory_order_release);`
`78`	`78`	`return success;`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`void IOSAudioPlayer::suspend()`
`82`	`82`	`{`
`83`		`- isRunning_.store(false);`
	`83`	`+ isRunning_.store(false, std::memory_order_release);`
`84`	`84`	`[audioPlayer_ suspend];`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`bool IOSAudioPlayer::isRunning() const`
`88`	`88`	`{`
`89`	`89`	`AudioEngine *audioEngine = [AudioEngine sharedInstance];`
`90`	`90`
`91`		`- return isRunning_.load() && [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;`
	`91`	`+ return isRunning_.load(std::memory_order_acquire) &&`
	`92`	`+ [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`void IOSAudioPlayer::cleanup()`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`[nativeRecorder_ start];`
`120`		`- state_.store(RecorderState::Recording);`
	`120`	`+ state_.store(RecorderState::Recording, std::memory_order_release);`
`121`	`121`	`return ReturnStatus<std::string>::Success(filePath_);`
`122`	`122`	`}`
`123`	`123`
`@@ -134,7 +134,7 @@`
`134`	`134`	`return ReturnStatus<std::tuple<std::string, double, double>>::Error("Not recording");`
`135`	`135`	`}`
`136`	`136`
`137`		`- state_.store(RecorderState::Idle);`
	`137`	`+ state_.store(RecorderState::Idle, std::memory_order_release);`
`138`	`138`	`[nativeRecorder_ stop];`
`139`	`139`
`140`	`140`	`if (usesFileOutput()) {`
`@@ -177,18 +177,18 @@`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`// TODO: atomic szpont?`
`180`		`- if (errorCallbackId_.load() != 0) {`
`181`		`- fileWriter_->setOnErrorCallback(errorCallbackId_.load());`
	`180`	`+ if (errorCallbackId_.load(std::memory_order_acquire) != 0) {`
	`181`	`+ fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));`
`182`	`182`	`}`
`183`	`183`
`184`		`- fileOutputEnabled_.store(true);`
	`184`	`+ fileOutputEnabled_.store(true, std::memory_order_release);`
`185`	`185`	`return ReturnStatus<std::string>::Success(filePath_);`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`void IOSAudioRecorder::disableFileOutput()`
`189`	`189`	`{`
`190`	`190`	`Locker lock(fileWriterMutex_);`
`191`		`- fileOutputEnabled_.store(false);`
	`191`	`+ fileOutputEnabled_.store(false, std::memory_order_release);`
`192`	`192`	`fileWriter_ = nullptr;`
`193`	`193`	`}`
`194`	`194`
`@@ -202,14 +202,14 @@`
`202`	`202`	`[nativeRecorder_ getBufferSize], [nativeRecorder_ getInputFormat].channelCount);`
`203`	`203`	`}`
`204`	`204`
`205`		`- isConnected_.store(true);`
	`205`	`+ isConnected_.store(true, std::memory_order_release);`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`void IOSAudioRecorder::disconnect()`
`209`	`209`	`{`
`210`	`210`	`Locker lock(adapterNodeMutex_);`
`211`	`211`	`adapterNode_ = nullptr;`
`212`		`- isConnected_.store(false);`
	`212`	`+ isConnected_.store(false, std::memory_order_release);`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`void IOSAudioRecorder::pause()`
`@@ -219,7 +219,7 @@`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`[nativeRecorder_ pause];`
`222`		`- state_.store(RecorderState::Paused);`
	`222`	`+ state_.store(RecorderState::Paused, std::memory_order_release);`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`void IOSAudioRecorder::resume()`
`@@ -229,20 +229,20 @@`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`[nativeRecorder_ resume];`
`232`		`- state_.store(RecorderState::Recording);`
	`232`	`+ state_.store(RecorderState::Recording, std::memory_order_release);`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`bool IOSAudioRecorder::isRecording() const`
`236`	`236`	`{`
`237`	`237`	`AudioEngine *audioEngine = [AudioEngine sharedInstance];`
`238`		`- return state_.load() == RecorderState::Recording &&`
	`238`	`+ return state_.load(std::memory_order_acquire) == RecorderState::Recording &&`
`239`	`239`	`[audioEngine getState] == AudioEngineState::AudioEngineStateRunning;`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`bool IOSAudioRecorder::isPaused() const`
`243`	`243`	`{`
`244`	`244`	`AudioEngine *audioEngine = [AudioEngine sharedInstance];`
`245`		`- auto currentState = state_.load();`
	`245`	`+ auto currentState = state_.load(std::memory_order_acquire);`
`246`	`246`
`247`	`247`	`if (currentState == RecorderState::Idle) {`
`248`	`248`	`return false;`
`@@ -254,7 +254,7 @@`
`254`	`254`
`255`	`255`	`bool IOSAudioRecorder::isIdle() const`
`256`	`256`	`{`
`257`		`- return state_.load() == RecorderState::Idle;`
	`257`	`+ return state_.load(std::memory_order_acquire) == RecorderState::Idle;`
`258`	`258`	`}`
`259`	`259`
`260`	`260`	`ReturnStatus<void> IOSAudioRecorder::setOnAudioReadyCallback(`
`@@ -277,18 +277,19 @@`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`
`280`		`- if (errorCallbackId_.load() != 0) {`
`281`		`- callback_->setOnErrorCallback(errorCallbackId_.load());`
	`280`	`+ // TODO: atomic szpont?`
	`281`	`+ if (errorCallbackId_.load(std::memory_order_acquire) != 0) {`
	`282`	`+ callback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));`
`282`	`283`	`}`
`283`	`284`
`284`		`- callbackOutputEnabled_.store(true);`
	`285`	`+ callbackOutputEnabled_.store(true, std::memory_order_release);`
`285`	`286`	`return ReturnStatus<void>::Success();`
`286`	`287`	`}`
`287`	`288`
`288`	`289`	`void IOSAudioRecorder::clearOnAudioReadyCallback()`
`289`	`290`	`{`
`290`	`291`	`Locker lock(callbackMutex_);`
`291`		`- callbackOutputEnabled_.store(false);`
	`292`	`+ callbackOutputEnabled_.store(false, std::memory_order_release);`
`292`	`293`	`callback_ = nullptr;`
`293`	`294`	`}`
`294`	`295`
`@@ -301,12 +302,12 @@`
`301`	`302`	`if (usesCallback()) {`
`302`	`303`	`callback_->setOnErrorCallback(callbackId);`
`303`	`304`	`}`
`304`		`- errorCallbackId_.store(callbackId);`
	`305`	`+ errorCallbackId_.store(callbackId, std::memory_order_release);`
`305`	`306`	`}`
`306`	`307`
`307`	`308`	`void IOSAudioRecorder::clearOnErrorCallback()`
`308`	`309`	`{`
`309`		`- errorCallbackId_.store(0);`
	`310`	`+ errorCallbackId_.store(0, std::memory_order_release);`
`310`	`311`
`311`	`312`	`if (usesFileOutput()) {`
`312`	`313`	`fileWriter_->clearOnErrorCallback();`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`fileURL_ = nil;`
`123`		`- framesWritten_.store(0);`
	`123`	`+ framesWritten_.store(0, std::memory_order_release);`
`124`	`124`
`125`	`125`	`return ReturnStatus<std::tuple<double, double>>::Success(`
`126`	`126`	`std::make_tuple(fileDuration, fileSizeBytesMb));`
`@@ -224,7 +224,7 @@`
`224`	`224`
`225`	`225`	`void FileWriter::setOnErrorCallback(uint64_t callbackId)`
`226`	`226`	`{`
`227`		`- errorCallbackId_.store(callbackId);`
	`227`	`+ errorCallbackId_.store(callbackId, std::memory_order_release);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`void FileWriter::clearOnErrorCallback()`
`@@ -234,7 +234,7 @@`
`234`	`234`
`235`	`235`	`void FileWriter::invokeOnErrorCallback(const std::string &message)`
`236`	`236`	`{`
`237`		`- uint64_t callbackId = errorCallbackId_.load();`
	`237`	`+ uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);`
`238`	`238`
`239`	`239`	`// TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,`
`240`	`240`	`// the callback could be cleared. We need to ensure that the callback is still valid when invoking it.`
Original file line number	Diff line number	Diff line change
`@@ -34,12 +34,12 @@`
`34`	`34`	`circularBus_[i] = busAudioArray;`
`35`	`35`	`}`
`36`	`36`
`37`		`- isInitialized_.store(true);`
	`37`	`+ isInitialized_.store(true, std::memory_order_release);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`RecorderCallback::~RecorderCallback()`
`41`	`41`	`{`
`42`		`- isInitialized_.store(false);`
	`42`	`+ isInitialized_.store(false, std::memory_order_release);`
`43`	`43`	`@autoreleasepool {`
`44`	`44`	`converter_ = nil;`
`45`	`45`	`bufferFormat_ = nil;`
`@@ -114,7 +114,7 @@`
`114`	`114`
`115`	`115`	`void RecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)`
`116`	`116`	`{`
`117`		`- if (!isInitialized_.load()) {`
	`117`	`+ if (!isInitialized_.load(std::memory_order_acquire)) {`
`118`	`118`	`return;`
`119`	`119`	`}`
`120`	`120`
`@@ -222,17 +222,17 @@`
`222`	`222`
`223`	`223`	`void RecorderCallback::setOnErrorCallback(uint64_t callbackId)`
`224`	`224`	`{`
`225`		`- errorCallbackId_.store(callbackId);`
	`225`	`+ errorCallbackId_.store(callbackId, std::memory_order_release);`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`void RecorderCallback::clearOnErrorCallback()`
`229`	`229`	`{`
`230`		`- errorCallbackId_.store(0);`
	`230`	`+ errorCallbackId_.store(0, std::memory_order_release);`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`void RecorderCallback::invokeOnErrorCallback(const std::string &message)`
`234`	`234`	`{`
`235`		`- uint64_t callbackId = errorCallbackId_.load();`
	`235`	`+ uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);`
`236`	`236`
`237`	`237`	`// TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,`
`238`	`238`	`// the callback could be cleared. We need to ensure that the callback is still valid when invoking it.`