Reinit. Audio Engine for MegaDrone on restart.

samples/MegaDrone/src/main/cpp/Synth.h

@@ -33,24 +33,19 @@ class Synth : public IRenderableAudio {
 public:
 
     Synth(int32_t sampleRate, int32_t channelCount) {
-
         for (int i = 0; i < kNumOscillators; ++i) {
             mOscs[i].setSampleRate(sampleRate);
             mOscs[i].setFrequency(kOscBaseFrequency+(static_cast<float>(i)/kOscDivisor));
             mOscs[i].setAmplitude(kOscAmplitude);
-
-            std::shared_ptr<IRenderableAudio> pOsc(&mOscs[i]);
-            mMixer.addTrack(pOsc);
+            mMixer.addTrack(&mOscs[i]);
         }
-
-        if (channelCount == oboe::ChannelCount::Stereo){
-            mOutputStage = std::make_shared<MonoToStereo>(&mMixer);
+        if (channelCount == oboe::ChannelCount::Stereo) {
+            mOutputStage =  &mConverter;
         } else {
-            mOutputStage.reset(&mMixer);
+            mOutputStage = &mMixer;
         }
     }
 
-    // From ISynth
     void setWaveOn(bool isEnabled) {
         for (auto &osc : mOscs) osc.setWaveOn(isEnabled);
     };
@@ -60,13 +55,14 @@ class Synth : public IRenderableAudio {
         mOutputStage->renderAudio(audioData, numFrames);
     };
 
-    virtual ~Synth() {}
+    virtual ~Synth() {
+    }
 private:
-
     // Rendering objects
     std::array<Oscillator, kNumOscillators> mOscs;
     Mixer mMixer;
-    std::shared_ptr<IRenderableAudio> mOutputStage;
+    MonoToStereo mConverter = MonoToStereo(&mMixer);
+    IRenderableAudio *mOutputStage; // This will point to either the mixer or converter, so it needs to be raw
 };
 
 

samples/MegaDrone/src/main/cpp/native-lib.cpp

@@ -20,7 +20,7 @@
 
 #include "AudioEngine.h"
 
-AudioEngine engine;
+AudioEngine *engine;
 
 std::vector<int> convertJavaArrayToVector(JNIEnv *env, jintArray intArray){
 
@@ -41,23 +41,23 @@ extern "C"
 JNIEXPORT void JNICALL
 Java_com_example_oboe_megadrone_MainActivity_startEngine(JNIEnv *env, jobject instance,
                                                          jintArray jCpuIds) {
-
+    engine = new AudioEngine;
     std::vector<int> cpuIds = convertJavaArrayToVector(env, jCpuIds);
-    engine.start(cpuIds);
+    engine->start(cpuIds);
 }
 
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_example_oboe_megadrone_MainActivity_stopEngine(JNIEnv *env, jobject instance) {
 
-    engine.stop();
-
+    engine->stop();
+    delete engine;
 }
 
 
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_example_oboe_megadrone_MainActivity_tap(JNIEnv *env, jobject instance, jboolean b) {
 
-    engine.tap(b);
+    engine->tap(b);
 }

samples/MegaDrone/src/main/java/com/example/oboe/megadrone/MainActivity.java

@@ -43,8 +43,8 @@ protected void onResume(){
     }
 
     protected void onPause(){
-        super.onPause();
         stopEngine();
+        super.onPause();
     }
 
     private native void stopEngine();

samples/RhythmGame/src/main/cpp/Game.cpp

@@ -219,7 +219,7 @@ bool Game::setupAudioSources() {
         LOGE("Could not load source data for clap sound");
         return false;
     }
-    mClap = std::make_shared<Player>(mClapSource);
+    mClap = std::make_unique<Player>(mClapSource);
 
     // Create a data source and player for our backing track
     std::shared_ptr<AAssetDataSource> backingTrackSource {
@@ -229,13 +229,13 @@ bool Game::setupAudioSources() {
         LOGE("Could not load source data for backing track");
         return false;
     }
-    mBackingTrack = std::make_shared<Player>(backingTrackSource);
+    mBackingTrack = std::make_unique<Player>(backingTrackSource);
     mBackingTrack->setPlaying(true);
     mBackingTrack->setLooping(true);
 
     // Add both players to a mixer
-    mMixer.addTrack(mClap);
-    mMixer.addTrack(mBackingTrack);
+    mMixer.addTrack(mClap.get());
+    mMixer.addTrack(mBackingTrack.get());
 
     return true;
 }

samples/RhythmGame/src/main/cpp/Game.h

@@ -59,8 +59,8 @@ class Game : public AudioStreamCallback {
 private:
     AAssetManager& mAssetManager;
     AudioStream *mAudioStream { nullptr };
-    std::shared_ptr<Player> mClap;
-    std::shared_ptr<Player> mBackingTrack;
+    std::unique_ptr<Player> mClap;
+    std::unique_ptr<Player> mBackingTrack;
     Mixer mMixer;
     std::unique_ptr<float[]> mConversionBuffer { nullptr }; // For float->int16 conversion
 

samples/shared/Mixer.h

@@ -27,6 +27,7 @@ constexpr uint8_t kMaxTracks = 100;
  * A Mixer object which sums the output from multiple tracks into a single output. The number of
  * input channels on each track must match the number of output channels (default 1=mono). This can
  * be changed by calling `setChannelCount`.
+ * The inputs to the mixer are not owned by the mixer, they should not be deleted while rendering.
  */
 class Mixer : public IRenderableAudio {
 
@@ -45,15 +46,15 @@ class Mixer : public IRenderableAudio {
         }
     }
 
-    void addTrack(std::shared_ptr<IRenderableAudio> renderer){
+    void addTrack(IRenderableAudio *renderer){
         mTracks[mNextFreeTrackIndex++] = renderer;
     }
 
     void setChannelCount(int32_t channelCount){ mChannelCount = channelCount; }
 
 private:
     float mixingBuffer[kBufferSize];
-    std::array<std::shared_ptr<IRenderableAudio>, kMaxTracks> mTracks;
+    std::array<IRenderableAudio*, kMaxTracks> mTracks;
     uint8_t mNextFreeTrackIndex = 0;
     int32_t mChannelCount = 1; // Default to mono
 };