Return a unique_ptr for the backend

Alc/alc.cpp

@@ -2203,7 +2203,6 @@ ALCdevice_struct::~ALCdevice_struct()
 {
     TRACE("%p\n", this);
 
-    delete Backend;
     Backend = nullptr;
 
     size_t count{std::accumulate(BufferList.cbegin(), BufferList.cend(), size_t{0u},
@@ -4037,7 +4036,7 @@ ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer,
 
     ALCenum err{ALC_INVALID_VALUE};
     { std::lock_guard<std::mutex> _{dev->BackendLock};
-        BackendBase *backend{dev->Backend};
+        BackendBase *backend{dev->Backend.get()};
         if(samples >= 0 && backend->availableSamples() >= (ALCuint)samples)
             err = backend->captureSamples(buffer, samples);
     }

Alc/backends/alsa.cpp

@@ -1292,12 +1292,12 @@ void AlsaBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *AlsaBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr AlsaBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new AlsaPlayback{device};
+        return BackendPtr{new AlsaPlayback{device}};
     if(type == BackendType::Capture)
-        return new AlsaCapture{device};
+        return BackendPtr{new AlsaCapture{device}};
     return nullptr;
 }
 

Alc/backends/alsa.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/base.cpp

@@ -19,7 +19,7 @@ void ALCdevice_Unlock(ALCdevice *device)
 
 ClockLatency GetClockLatency(ALCdevice *device)
 {
-    BackendBase *backend{device->Backend};
+    BackendBase *backend{device->Backend.get()};
     ClockLatency ret{backend->getClockLatency()};
     ret.Latency += device->FixedLatency;
     return ret;

Alc/backends/base.h

@@ -1,6 +1,7 @@
 #ifndef ALC_BACKENDS_BASE_H
 #define ALC_BACKENDS_BASE_H
 
+#include <memory>
 #include <chrono>
 #include <string>
 #include <mutex>
@@ -53,7 +54,7 @@ struct BackendBase {
     BackendBase(ALCdevice *device) noexcept;
     virtual ~BackendBase();
 };
-
+using BackendPtr = std::unique_ptr<BackendBase>;
 
 enum class BackendType {
     Playback,
@@ -70,7 +71,7 @@ struct BackendFactory {
 
     virtual void probe(DevProbe type, std::string *outnames) = 0;
 
-    virtual BackendBase *createBackend(ALCdevice *device, BackendType type) = 0;
+    virtual BackendPtr createBackend(ALCdevice *device, BackendType type) = 0;
 };
 
 #endif /* ALC_BACKENDS_BASE_H */

Alc/backends/coreaudio.cpp

@@ -703,11 +703,11 @@ void CoreAudioBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *CoreAudioBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr CoreAudioBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new CoreAudioPlayback{device};
+        return BackendPtr{new CoreAudioPlayback{device}};
     if(type == BackendType::Capture)
-        return new CoreAudioCapture{device};
+        return BackendPtr{new CoreAudioCapture{device}};
     return nullptr;
 }

Alc/backends/coreaudio.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/dsound.cpp

@@ -949,11 +949,11 @@ void DSoundBackendFactory::probe(DevProbe type, std::string *outnames)
         CoUninitialize();
 }
 
-BackendBase *DSoundBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr DSoundBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new DSoundPlayback{device};
+        return BackendPtr{new DSoundPlayback{device}};
     if(type == BackendType::Capture)
-        return new DSoundCapture{device};
+        return BackendPtr{new DSoundCapture{device}};
     return nullptr;
 }

Alc/backends/dsound.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/jack.cpp

@@ -558,10 +558,10 @@ void JackBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *JackBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr JackBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new JackPlayback{device};
+        return BackendPtr{new JackPlayback{device}};
     return nullptr;
 }
 

Alc/backends/jack.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/loopback.cpp

@@ -70,10 +70,10 @@ bool LoopbackBackendFactory::querySupport(BackendType type)
 void LoopbackBackendFactory::probe(DevProbe, std::string*)
 { }
 
-BackendBase *LoopbackBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr LoopbackBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Loopback)
-        new LoopbackBackend{device};
+        return BackendPtr{new LoopbackBackend{device}};
     return nullptr;
 }
 

Alc/backends/loopback.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/null.cpp

@@ -169,10 +169,10 @@ void NullBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *NullBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr NullBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new NullBackend{device};
+        return BackendPtr{new NullBackend{device}};
     return nullptr;
 }
 

Alc/backends/null.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/opensl.cpp

@@ -934,12 +934,12 @@ void OSLBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *OSLBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr OSLBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new OpenSLPlayback{device};
+        return BackendPtr{new OpenSLPlayback{device}};
     if(type == BackendType::Capture)
-        return new OpenSLCapture{device};
+        return BackendPtr{new OpenSLCapture{device}};
     return nullptr;
 }
 

Alc/backends/opensl.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/oss.cpp

@@ -751,11 +751,11 @@ void OSSBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *OSSBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr OSSBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new OSSPlayback{device};
+        return BackendPtr{new OSSPlayback{device}};
     if(type == BackendType::Capture)
-        return new OSScapture{device};
+        return BackendPtr{new OSScapture{device}};
     return nullptr;
 }

Alc/backends/oss.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/portaudio.cpp

@@ -467,12 +467,12 @@ void PortBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *PortBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr PortBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new PortPlayback{device};
+        return BackendPtr{new PortPlayback{device}};
     if(type == BackendType::Capture)
-        return new PortCapture{device};
+        return BackendPtr{new PortCapture{device}};
     return nullptr;
 }
 

Alc/backends/portaudio.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/pulseaudio.cpp

@@ -1664,12 +1664,12 @@ void PulseBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *PulseBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr PulseBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new PulsePlayback{device};
+        return BackendPtr{new PulsePlayback{device}};
     if(type == BackendType::Capture)
-        return new PulseCapture{device};
+        return BackendPtr{new PulseCapture{device}};
     return nullptr;
 }
 

Alc/backends/pulseaudio.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/qsa.cpp

@@ -952,12 +952,12 @@ void QSABackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *QSABackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr QSABackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new PlaybackWrapper{device};
+        return BackendPtr{new PlaybackWrapper{device}};
     if(type == BackendType::Capture)
-        return new CaptureWrapper{device};
+        return BackendPtr{new CaptureWrapper{device}};
     return nullptr;
 }
 

Alc/backends/qsa.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/sdl2.cpp

@@ -223,9 +223,9 @@ void SDL2BackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *SDL2BackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SDL2BackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new Sdl2Backend{device};
+        return BackendPtr{new Sdl2Backend{device}};
     return nullptr;
 }

Alc/backends/sdl2.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/sndio.cpp

@@ -492,11 +492,11 @@ void SndIOBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *SndIOBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SndIOBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new SndioPlayback{device};
+        return BackendPtr{new SndioPlayback{device}};
     if(type == BackendType::Capture)
-        return new SndioCapture{device};
+        return BackendPtr{new SndioCapture{device}};
     return nullptr;
 }

Alc/backends/sndio.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/solaris.cpp

@@ -292,9 +292,9 @@ void SolarisBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *SolarisBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SolarisBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new SolarisBackend{device};
+        return BackendPtr{new SolarisBackend{device}};
     return nullptr;
 }

Alc/backends/solaris.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/wasapi.cpp

@@ -1810,12 +1810,12 @@ void WasapiBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *WasapiBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WasapiBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new WasapiPlayback{device};
+        return BackendPtr{new WasapiPlayback{device}};
     if(type == BackendType::Capture)
-        return new WasapiCapture{device};
+        return BackendPtr{new WasapiCapture{device}};
     return nullptr;
 }
 

Alc/backends/wasapi.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/wave.cpp

@@ -380,10 +380,10 @@ void WaveBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *WaveBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WaveBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new WaveBackend{device};
+        return BackendPtr{new WaveBackend{device}};
     return nullptr;
 }
 

Alc/backends/wave.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

Alc/backends/winmm.cpp

@@ -634,12 +634,12 @@ void WinMMBackendFactory::probe(DevProbe type, std::string *outnames)
     }
 }
 
-BackendBase *WinMMBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WinMMBackendFactory::createBackend(ALCdevice *device, BackendType type)
 {
     if(type == BackendType::Playback)
-        return new WinMMPlayback{device};
+        return BackendPtr{new WinMMPlayback{device}};
     if(type == BackendType::Capture)
-        return new WinMMCapture{device};
+        return BackendPtr{new WinMMCapture{device}};
     return nullptr;
 }
 

Alc/backends/winmm.h

@@ -12,7 +12,7 @@ public:
 
     void probe(DevProbe type, std::string *outnames) override;
 
-    BackendBase *createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };

OpenAL32/Include/alMain.h

@@ -786,7 +786,7 @@ struct ALCdevice_struct {
     std::atomic<ALCcontext*> ContextList{nullptr};
 
     std::mutex BackendLock;
-    BackendBase *Backend{nullptr};
+    std::unique_ptr<BackendBase> Backend;
 
     std::atomic<ALCdevice*> next{nullptr};