kodi-995.01-fernetmenta.patch

From f96268818f3d054afb71d22be580d9cdedd7eb66 Mon Sep 17 00:00:00 2001
From: xbmc <fernetmenta@online.de>
Date: Thu, 11 Oct 2012 12:05:50 +0200
Subject: [PATCH 01/10] vdpau: advanced settings for auto deinterlacing

---
 xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp | 8 ++++----
 xbmc/settings/AdvancedSettings.cpp             | 4 ++++
 xbmc/settings/AdvancedSettings.h               | 2 ++
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp b/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp
index 1871eb8..5e18248 100644
--- a/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp
+++ b/xbmc/cores/dvdplayer/DVDCodecs/Video/VDPAU.cpp
@@ -1965,10 +1965,10 @@ EINTERLACEMETHOD CMixer::GetDeinterlacingMethod(bool log /* = false */)
   if (method == VS_INTERLACEMETHOD_AUTO)
   {
     int deint = -1;
-//    if (m_config.outHeight >= 720)
-//      deint = g_advancedSettings.m_videoVDPAUdeintHD;
-//    else
-//      deint = g_advancedSettings.m_videoVDPAUdeintSD;
+    if (m_config.outHeight >= 720)
+      deint = g_advancedSettings.m_videoVDPAUdeintHD;
+    else
+      deint = g_advancedSettings.m_videoVDPAUdeintSD;
 
     if (deint != -1)
     {
diff --git a/xbmc/settings/AdvancedSettings.cpp b/xbmc/settings/AdvancedSettings.cpp
index e6d58b3..1f92402 100644
--- a/xbmc/settings/AdvancedSettings.cpp
+++ b/xbmc/settings/AdvancedSettings.cpp
@@ -157,6 +157,8 @@ void CAdvancedSettings::Initialize()
   m_videoAutoScaleMaxFps = 30.0f;
   m_videoDisableBackgroundDeinterlace = false;
   m_videoCaptureUseOcclusionQuery = -1; //-1 is auto detect
+  m_videoVDPAUdeintHD = -1;
+  m_videoVDPAUdeintSD = -1;
   m_videoVDPAUtelecine = false;
   m_videoVDPAUdeintSkipChromaHD = false;
   m_useFfmpegVda = false;
@@ -589,6 +591,8 @@ void CAdvancedSettings::ParseSettingsFile(const CStdString &file)
     XMLUtils::GetFloat(pElement,"autoscalemaxfps",m_videoAutoScaleMaxFps, 0.0f, 1000.0f);
     XMLUtils::GetBoolean(pElement, "disablebackgrounddeinterlace", m_videoDisableBackgroundDeinterlace);
     XMLUtils::GetInt(pElement, "useocclusionquery", m_videoCaptureUseOcclusionQuery, -1, 1);
+    XMLUtils::GetInt(pElement,"vdpauHDdeint",m_videoVDPAUdeintHD);
+    XMLUtils::GetInt(pElement,"vdpauSDdeint",m_videoVDPAUdeintSD);
     XMLUtils::GetBoolean(pElement,"vdpauInvTelecine",m_videoVDPAUtelecine);
     XMLUtils::GetBoolean(pElement,"vdpauHDdeintSkipChroma",m_videoVDPAUdeintSkipChromaHD);
     XMLUtils::GetBoolean(pElement,"useffmpegvda", m_useFfmpegVda);
diff --git a/xbmc/settings/AdvancedSettings.h b/xbmc/settings/AdvancedSettings.h
index fb5a837..9b805a0 100644
--- a/xbmc/settings/AdvancedSettings.h
+++ b/xbmc/settings/AdvancedSettings.h
@@ -162,6 +162,8 @@ class CAdvancedSettings : public ISettingCallback, public ISettingsHandler
     int m_videoPercentSeekBackwardBig;
     CStdString m_videoPPFFmpegDeint;
     CStdString m_videoPPFFmpegPostProc;
+    int m_videoVDPAUdeintHD;
+    int m_videoVDPAUdeintSD;
     bool m_videoVDPAUtelecine;
     bool m_videoVDPAUdeintSkipChromaHD;
     bool m_musicUseTimeSeeking;

From aecf2bd32b23a933d65eff1e32a295fdadaf8867 Mon Sep 17 00:00:00 2001
From: Rainer Hochecker <fernetmenta@online.de>
Date: Thu, 25 Jul 2013 17:18:13 +0200
Subject: [PATCH 02/10] ActiveAE: slightly reduce buffer size

---
 xbmc/cores/AudioEngine/Engines/ActiveAE/ActiveAE.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/xbmc/cores/AudioEngine/Engines/ActiveAE/ActiveAE.cpp b/xbmc/cores/AudioEngine/Engines/ActiveAE/ActiveAE.cpp
index 6e9900f..17b6c01 100644
--- a/xbmc/cores/AudioEngine/Engines/ActiveAE/ActiveAE.cpp
+++ b/xbmc/cores/AudioEngine/Engines/ActiveAE/ActiveAE.cpp
@@ -33,8 +33,8 @@ using namespace ActiveAE;
 
 #include "utils/TimeUtils.h"
 
-#define MAX_CACHE_LEVEL 0.5   // total cache time of stream in seconds
-#define MAX_WATER_LEVEL 0.25  // buffered time after stream stages in seconds
+#define MAX_CACHE_LEVEL 0.4   // total cache time of stream in seconds
+#define MAX_WATER_LEVEL 0.2   // buffered time after stream stages in seconds
 #define MAX_BUFFER_TIME 0.1   // max time of a buffer in seconds
 
 void CEngineStats::Reset(unsigned int sampleRate)

From 817f21c47b7c000b6a49596b862adfa6de4feec7 Mon Sep 17 00:00:00 2001
From: Rainer Hochecker <fernetmenta@online.de>
Date: Sat, 4 Oct 2014 21:25:31 +0200
Subject: [PATCH 04/10] vaapi: lock gfx context on pre-cleanup

---
 xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp b/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp
index ed7bd74..9c1dd84 100644
--- a/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp
+++ b/xbmc/cores/dvdplayer/DVDCodecs/Video/VAAPI.cpp
@@ -628,6 +628,7 @@ long CDecoder::Release()
     if (g_advancedSettings.CanLogComponent(LOGVIDEO))
       CLog::Log(LOGDEBUG,"VAAPI::Release pre-cleanup");
 
+    CSingleLock lock1(g_graphicsContext);
     Message *reply;
     if (m_vaapiOutput.m_controlPort.SendOutMessageSync(COutputControlProtocol::PRECLEANUP,
                                                    &reply,

From d0fa19a4c6ce0967d4bfdab9836696b379895064 Mon Sep 17 00:00:00 2001
From: Anssi Hannula <anssi@xbmc.org>
Date: Sun, 19 Oct 2014 21:34:47 +0300
Subject: [PATCH 05/10] [linux] Add FDEventMonitor for monitoring file
 descriptors

Add FDEventMonitor helper thread for monitoring file descriptors for
events (ready for read, ready for write) without the need for spawning
a separate thread with a tight loop around poll()/select().

FDEventMonitor uses an eventfd for signaling poll() instead of a
timeout, therefore it can sleep for long times in case of no events but
still immediately respond to e.g. shutdown.
---
 xbmc/linux/FDEventMonitor.cpp | 248 ++++++++++++++++++++++++++++++++++++++++++
 xbmc/linux/FDEventMonitor.h   |  89 +++++++++++++++
 xbmc/linux/Makefile.in        |   1 +
 3 files changed, 338 insertions(+)
 create mode 100644 xbmc/linux/FDEventMonitor.cpp
 create mode 100644 xbmc/linux/FDEventMonitor.h

diff --git a/xbmc/linux/FDEventMonitor.cpp b/xbmc/linux/FDEventMonitor.cpp
new file mode 100644
index 0000000..4a41477
--- /dev/null
+++ b/xbmc/linux/FDEventMonitor.cpp
@@ -0,0 +1,248 @@
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "system.h"
+#ifdef HAS_ALSA
+
+#include <poll.h>
+#include <sys/eventfd.h>
+#include <errno.h>
+
+#include "utils/log.h"
+
+#include "FDEventMonitor.h"
+
+CFDEventMonitor::CFDEventMonitor() :
+  CThread("FDEventMonitor"),
+  m_nextID(0),
+  m_wakeupfd(-1)
+{
+}
+
+CFDEventMonitor::~CFDEventMonitor()
+{
+  CSingleLock lock(m_mutex);
+  InterruptPoll();
+
+  if (m_wakeupfd >= 0)
+  {
+    /* sets m_bStop */
+    StopThread(false);
+
+    /* wake up the poll() call */
+    eventfd_write(m_wakeupfd, 1);
+
+    /* Wait for the thread to stop */
+    {
+      CSingleExit exit(m_mutex);
+      StopThread(true);
+    }
+
+    close(m_wakeupfd);
+  }
+}
+
+void CFDEventMonitor::AddFD(const MonitoredFD& monitoredFD, int& id)
+{
+  CSingleLock lock(m_mutex);
+  InterruptPoll();
+
+  AddFDLocked(monitoredFD, id);
+
+  StartMonitoring();
+}
+
+void CFDEventMonitor::AddFDs(const std::vector<MonitoredFD>& monitoredFDs,
+                             std::vector<int>& ids)
+{
+  CSingleLock lock(m_mutex);
+  InterruptPoll();
+
+  for (unsigned int i = 0; i < monitoredFDs.size(); ++i)
+  {
+    int id;
+    AddFDLocked(monitoredFDs[i], id);
+    ids.push_back(id);
+  }
+
+  StartMonitoring();
+}
+
+void CFDEventMonitor::RemoveFD(int id)
+{
+  CSingleLock lock(m_mutex);
+  InterruptPoll();
+
+  if (m_monitoredFDs.erase(id) != 1)
+  {
+    CLog::Log(LOGERROR, "CFDEventMonitor::RemoveFD - Tried to remove non-existing monitoredFD %d", id);
+  }
+
+  UpdatePollDescs();
+}
+
+void CFDEventMonitor::RemoveFDs(const std::vector<int>& ids)
+{
+  CSingleLock lock(m_mutex);
+  InterruptPoll();
+
+  for (unsigned int i = 0; i < ids.size(); ++i)
+  {
+    if (m_monitoredFDs.erase(ids[i]) != 1)
+    {
+      CLog::Log(LOGERROR, "CFDEventMonitor::RemoveFDs - Tried to remove non-existing monitoredFD %d while removing %u FDs", ids[i], (unsigned)ids.size());
+    }
+  }
+
+  UpdatePollDescs();
+}
+
+void CFDEventMonitor::Process()
+{
+  eventfd_t dummy;
+
+  while (!m_bStop)
+  {
+    CSingleLock lock(m_mutex);
+    CSingleLock pollLock(m_pollMutex);
+
+    /*
+     * Leave the main mutex here to allow another thread to
+     * lock it while we are in poll().
+     * By then calling InterruptPoll() the other thread can
+     * wake up poll and wait for the processing to pause at
+     * the above lock(m_mutex).
+     */
+    lock.Leave();
+
+    int err = poll(&m_pollDescs[0], m_pollDescs.size(), -1);
+
+    if (err < 0 && errno != EINTR)
+    {
+      CLog::Log(LOGERROR, "CFDEventMonitor::Process - poll() failed, error %d, stopping monitoring", errno);
+      StopThread(false);
+    }
+
+    // Something woke us up - either there is data available or we are being
+    // paused/stopped via m_wakeupfd.
+
+    for (unsigned int i = 0; i < m_pollDescs.size(); ++i)
+    {
+      struct pollfd& pollDesc = m_pollDescs[i];
+      int id = m_monitoredFDbyPollDescs[i];
+      const MonitoredFD& monitoredFD = m_monitoredFDs[id];
+
+      if (pollDesc.revents)
+      {
+        if (monitoredFD.callback)
+        {
+          monitoredFD.callback(id, pollDesc.fd, pollDesc.revents,
+                               monitoredFD.callbackData);
+        }
+
+        if (pollDesc.revents & (POLLERR | POLLHUP | POLLNVAL))
+        {
+          CLog::Log(LOGERROR, "CFDEventMonitor::Process - polled fd %d got revents 0x%x, removing it", pollDesc.fd, pollDesc.revents);
+
+          /* Probably would be nice to inform our caller that their FD was
+           * dropped, but oh well... */
+          m_monitoredFDs.erase(id);
+          UpdatePollDescs();
+        }
+
+        pollDesc.revents = 0;
+      }
+    }
+
+    /* flush wakeup fd */
+    eventfd_read(m_wakeupfd, &dummy);
+
+  }
+}
+
+void CFDEventMonitor::AddFDLocked(const MonitoredFD& monitoredFD, int& id)
+{
+  id = m_nextID;
+
+  while (m_monitoredFDs.count(id))
+  {
+    ++id;
+  }
+  m_nextID = id + 1;
+
+  m_monitoredFDs[id] = monitoredFD;
+
+  AddPollDesc(id, monitoredFD.fd, monitoredFD.events);
+}
+
+void CFDEventMonitor::AddPollDesc(int id, int fd, short events)
+{
+  struct pollfd newPollFD;
+  newPollFD.fd = fd;
+  newPollFD.events = events;
+  newPollFD.revents = 0;
+
+  m_pollDescs.push_back(newPollFD);
+  m_monitoredFDbyPollDescs.push_back(id);
+}
+
+void CFDEventMonitor::UpdatePollDescs()
+{
+  m_monitoredFDbyPollDescs.clear();
+  m_pollDescs.clear();
+
+  for (std::map<int, MonitoredFD>::iterator it = m_monitoredFDs.begin();
+       it != m_monitoredFDs.end(); ++it)
+  {
+    AddPollDesc(it->first, it->second.fd, it->second.events);
+  }
+}
+
+void CFDEventMonitor::StartMonitoring()
+{
+  if (!IsRunning())
+  {
+    /* Start the monitoring thread */
+
+    m_wakeupfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+    if (m_wakeupfd < 0)
+    {
+      CLog::Log(LOGERROR, "CFDEventMonitor::StartMonitoring - Failed to create eventfd, error %d", errno);
+      return;
+    }
+
+    /* Add wakeup fd to the fd list */
+    int id;
+    AddFDLocked(MonitoredFD(m_wakeupfd, POLLIN, NULL, NULL), id);
+
+    Create(false);
+  }
+}
+
+void CFDEventMonitor::InterruptPoll()
+{
+  if (m_wakeupfd >= 0)
+  {
+    eventfd_write(m_wakeupfd, 1);
+    /* wait for the poll() result handling (if any) to end */
+    CSingleLock pollLock(m_pollMutex);
+  }
+}
+
+#endif
diff --git a/xbmc/linux/FDEventMonitor.h b/xbmc/linux/FDEventMonitor.h
new file mode 100644
index 0000000..4602d12
--- /dev/null
+++ b/xbmc/linux/FDEventMonitor.h
@@ -0,0 +1,89 @@
+#pragma once
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "system.h"
+
+#include <vector>
+#include <map>
+
+#include "threads/CriticalSection.h"
+#include "threads/Thread.h"
+
+#include "utils/GlobalsHandling.h"
+
+/**
+ * Monitor a file descriptor with callback on poll() events.
+ */
+class CFDEventMonitor : private CThread
+{
+public:
+
+  typedef void (*EventCallback)(int id, int fd, short revents, void *data);
+
+  struct MonitoredFD
+  {
+    int fd; /**< File descriptor to be monitored */
+    short events; /**< Events to be monitored (see poll(2)) */
+
+    EventCallback callback; /** Callback to be called on events */
+    void *callbackData; /** data parameter for EventCallback */
+
+    MonitoredFD(int fd_, short events_, EventCallback callback_, void *callbackData_) :
+      fd(fd_), events(events_), callback(callback_), callbackData(callbackData_) {}
+    MonitoredFD() : fd(-1), events(0), callback(NULL), callbackData(NULL) {}
+  };
+
+  CFDEventMonitor();
+  ~CFDEventMonitor();
+
+  void AddFD(const MonitoredFD& monitoredFD, int& id);
+  void AddFDs(const std::vector<MonitoredFD>& monitoredFDs, std::vector<int>& ids);
+
+  void RemoveFD(int id);
+  void RemoveFDs(const std::vector<int>& ids);
+
+protected:
+  virtual void Process();
+
+private:
+  void AddFDLocked(const MonitoredFD& monitoredFD, int& id);
+
+  void AddPollDesc(int id, int fd, short events);
+  void UpdatePollDescs();
+
+  void StartMonitoring();
+  void InterruptPoll();
+
+  std::map<int, MonitoredFD> m_monitoredFDs;
+
+  /* these are kept synchronized */
+  std::vector<int> m_monitoredFDbyPollDescs;
+  std::vector<struct pollfd> m_pollDescs;
+
+  int m_nextID;
+  int m_wakeupfd;
+
+  CCriticalSection m_mutex;
+  CCriticalSection m_pollMutex;
+};
+
+XBMC_GLOBAL_REF(CFDEventMonitor, g_fdEventMonitor);
+#define g_fdEventMonitor XBMC_GLOBAL_USE(CFDEventMonitor)
diff --git a/xbmc/linux/Makefile.in b/xbmc/linux/Makefile.in
index c147d8f..744fd06 100644
--- a/xbmc/linux/Makefile.in
+++ b/xbmc/linux/Makefile.in
@@ -4,6 +4,7 @@ SRCS  = ConvUtils.cpp
 SRCS += DBusUtil.cpp
 SRCS += DBusMessage.cpp
 SRCS += DBusReserve.cpp
+SRCS += FDEventMonitor.cpp
 SRCS += LinuxResourceCounter.cpp
 SRCS += LinuxTimezone.cpp
 SRCS += PosixMountProvider.cpp

From 9fe447e12d86fbd75995d8c0f0fa6d89786c6983 Mon Sep 17 00:00:00 2001
From: Anssi Hannula <anssi@xbmc.org>
Date: Sun, 19 Oct 2014 21:36:44 +0300
Subject: [PATCH 06/10] [AE] ALSA: Add ALSADeviceMonitor for monitoring card
 removals/additions

---
 xbmc/cores/AudioEngine/Makefile.in                 |   1 +
 xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp        |   8 ++
 xbmc/cores/AudioEngine/Sinks/AESinkALSA.h          |  10 ++
 .../AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp   | 131 +++++++++++++++++++++
 .../AudioEngine/Sinks/alsa/ALSADeviceMonitor.h     |  49 ++++++++
 5 files changed, 199 insertions(+)
 create mode 100644 xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
 create mode 100644 xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h

diff --git a/xbmc/cores/AudioEngine/Makefile.in b/xbmc/cores/AudioEngine/Makefile.in
index 8491050..6f818e2 100644
--- a/xbmc/cores/AudioEngine/Makefile.in
+++ b/xbmc/cores/AudioEngine/Makefile.in
@@ -49,6 +49,7 @@ SRCS += Sinks/osx/CoreAudioHelpers.cpp
 SRCS += Sinks/osx/CoreAudioStream.cpp
 else
 SRCS += Sinks/AESinkALSA.cpp
+SRCS += Sinks/alsa/ALSADeviceMonitor.cpp
 SRCS += Sinks/AESinkOSS.cpp
 ifeq (@USE_PULSE@,1)
 SRCS += Sinks/AESinkPULSE.cpp
diff --git a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
index d30cbab..c33d4dd 100644
--- a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
+++ b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
@@ -1101,6 +1101,10 @@ bool CAESinkALSA::OpenPCMDevice(const std::string &name, const std::string &para
 
 void CAESinkALSA::EnumerateDevicesEx(AEDeviceInfoList &list, bool force)
 {
+#if HAVE_LIBUDEV
+  m_deviceMonitor.Start();
+#endif
+
   /* ensure that ALSA has been initialized */
   snd_lib_error_set_handler(sndLibErrorHandler);
   if(!snd_config || force)
@@ -1612,4 +1616,8 @@ void CAESinkALSA::sndLibErrorHandler(const char *file, int line, const char *fun
   va_end(arg);
 }
 
+#if HAVE_LIBUDEV
+CALSADeviceMonitor CAESinkALSA::m_deviceMonitor; // ARGH
+#endif
+
 #endif
diff --git a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
index c284255..54402f9 100644
--- a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
+++ b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
@@ -24,6 +24,7 @@
 
 #include "cores/AudioEngine/Interfaces/AESink.h"
 #include "cores/AudioEngine/Utils/AEDeviceInfo.h"
+#include "cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h"
 #include <stdint.h>
 
 #define ALSA_PCM_NEW_HW_PARAMS_API
@@ -31,6 +32,10 @@
 
 #include "threads/CriticalSection.h"
 
+// ARGH... this is apparently needed to avoid FDEventMonitor
+// being destructed before CALSA*Monitor below.
+#include "linux/FDEventMonitor.h"
+
 class CAESinkALSA : public IAESink
 {
 public:
@@ -81,6 +86,11 @@ class CAESinkALSA : public IAESink
   // support fragmentation, e.g. looping in the sink to get a certain amount of data onto the device
   bool              m_fragmented;
   unsigned int      m_originalPeriodSize;
+
+#if HAVE_LIBUDEV
+  static CALSADeviceMonitor m_deviceMonitor;
+#endif
+
   struct ALSAConfig
   {
     unsigned int sampleRate;
diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
new file mode 100644
index 0000000..e3269ad
--- /dev/null
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
@@ -0,0 +1,131 @@
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "system.h"
+#if defined(HAS_ALSA) && defined(HAVE_LIBUDEV)
+
+#include <libudev.h>
+
+#include "ALSADeviceMonitor.h"
+#include "AEFactory.h"
+#include "linux/FDEventMonitor.h"
+#include "utils/log.h"
+
+CALSADeviceMonitor::CALSADeviceMonitor() :
+  m_fdMonitorId(0),
+  m_udev(NULL),
+  m_udevMonitor(NULL)
+{
+}
+
+CALSADeviceMonitor::~CALSADeviceMonitor()
+{
+  Stop();
+}
+
+void CALSADeviceMonitor::Start()
+{
+  int err;
+
+  if (!m_udev)
+  {
+    m_udev = udev_new();
+    if (!m_udev)
+    {
+      CLog::Log(LOGWARNING, "CALSADeviceMonitor::Start - Unable to open udev handle");
+      return;
+    }
+
+    m_udevMonitor = udev_monitor_new_from_netlink(m_udev, "udev");
+    if (!m_udevMonitor)
+    {
+      CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_new_from_netlink() failed");
+      goto err_unref_udev;
+    }
+
+    err = udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitor, "sound", NULL);
+    if (err)
+    {
+      CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_filter_add_match_subsystem_devtype() failed");
+      goto err_unref_monitor;
+    }
+
+    err = udev_monitor_enable_receiving(m_udevMonitor);
+    if (err)
+    {
+      CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_enable_receiving() failed");
+      goto err_unref_monitor;
+    }
+
+    g_fdEventMonitor.AddFD(
+        CFDEventMonitor::MonitoredFD(udev_monitor_get_fd(m_udevMonitor),
+                                     POLLIN, FDEventCallback, m_udevMonitor),
+        m_fdMonitorId);
+  }
+
+  return;
+
+err_unref_monitor:
+  udev_monitor_unref(m_udevMonitor);
+  m_udevMonitor = NULL;
+err_unref_udev:
+  udev_unref(m_udev);
+  m_udev = NULL;
+}
+
+void CALSADeviceMonitor::Stop()
+{
+  if (m_udev)
+  {
+    g_fdEventMonitor.RemoveFD(m_fdMonitorId);
+
+    udev_monitor_unref(m_udevMonitor);
+    m_udevMonitor = NULL;
+    udev_unref(m_udev);
+    m_udev = NULL;
+  }
+}
+
+void CALSADeviceMonitor::FDEventCallback(int id, int fd, short revents, void *data)
+{
+  struct udev_monitor *udevMonitor = (struct udev_monitor *)data;
+  bool audioDevicesChanged = false;
+  struct udev_device *device;
+
+  while ((device = udev_monitor_receive_device(udevMonitor)) != NULL)
+  {
+    const char* action = udev_device_get_action(device);
+    const char* soundInitialized = udev_device_get_property_value(device, "SOUND_INITIALIZED");
+
+    /* cardX devices emit a "change" event when ready (i.e. all subdevices added) */
+    if (action && soundInitialized &&
+        (strcmp(action, "change") == 0 || strcmp(action, "remove") == 0))
+    {
+      audioDevicesChanged = true;
+    }
+    udev_device_unref(device);
+  }
+
+  if (audioDevicesChanged)
+  {
+    CAEFactory::DeviceChange();
+  }
+}
+
+#endif
diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h
new file mode 100644
index 0000000..f9e2f26
--- /dev/null
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h
@@ -0,0 +1,49 @@
+#pragma once
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "system.h"
+#if defined(HAS_ALSA) && defined(HAVE_LIBUDEV)
+
+#include <string>
+#include <vector>
+
+#include <alsa/asoundlib.h>
+
+class CALSADeviceMonitor
+{
+public:
+  CALSADeviceMonitor();
+  ~CALSADeviceMonitor();
+
+  void Start();
+  void Stop();
+
+private:
+  static void FDEventCallback(int id, int fd, short revents, void *data);
+
+  int m_fdMonitorId;
+
+  struct udev *m_udev;
+  struct udev_monitor* m_udevMonitor;
+};
+
+#endif
+

From 750969d09c060e59957d7aa6a582c0406a24cf21 Mon Sep 17 00:00:00 2001
From: Anssi Hannula <anssi@xbmc.org>
Date: Sun, 19 Oct 2014 21:37:49 +0300
Subject: [PATCH 07/10] [AE] ALSA: Add ALSADeviceMonitor for monitoring ELD
 changes

ELD changes can happen e.g. when the connected HDMI sink is changed.
---
 xbmc/cores/AudioEngine/Makefile.in                 |   1 +
 xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp        |   9 ++
 xbmc/cores/AudioEngine/Sinks/AESinkALSA.h          |   2 +
 .../AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp | 173 +++++++++++++++++++++
 .../AudioEngine/Sinks/alsa/ALSAHControlMonitor.h   |  69 ++++++++
 5 files changed, 254 insertions(+)
 create mode 100644 xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
 create mode 100644 xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h

diff --git a/xbmc/cores/AudioEngine/Makefile.in b/xbmc/cores/AudioEngine/Makefile.in
index 6f818e2..024618e 100644
--- a/xbmc/cores/AudioEngine/Makefile.in
+++ b/xbmc/cores/AudioEngine/Makefile.in
@@ -50,6 +50,7 @@ SRCS += Sinks/osx/CoreAudioStream.cpp
 else
 SRCS += Sinks/AESinkALSA.cpp
 SRCS += Sinks/alsa/ALSADeviceMonitor.cpp
+SRCS += Sinks/alsa/ALSAHControlMonitor.cpp
 SRCS += Sinks/AESinkOSS.cpp
 ifeq (@USE_PULSE@,1)
 SRCS += Sinks/AESinkPULSE.cpp
diff --git a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
index c33d4dd..634f35a 100644
--- a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
+++ b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.cpp
@@ -1118,6 +1118,8 @@ void CAESinkALSA::EnumerateDevicesEx(AEDeviceInfoList &list, bool force)
   snd_config_t *config;
   snd_config_copy(&config, snd_config);
 
+  m_controlMonitor.Clear();
+
   /* Always enumerate the default device.
    * Note: If "default" is a stereo device, EnumerateDevice()
    * will automatically add "@" instead to enable surroundXX mangling.
@@ -1195,6 +1197,8 @@ void CAESinkALSA::EnumerateDevicesEx(AEDeviceInfoList &list, bool force)
   }
   snd_device_name_free_hint(hints);
 
+  m_controlMonitor.Start();
+
   /* set the displayname for default device */
   if (!list.empty() && list[0].m_deviceName == "default")
   {
@@ -1375,6 +1379,10 @@ void CAESinkALSA::EnumerateDevice(AEDeviceInfoList &list, const std::string &dev
           {
             snd_hctl_load(hctl);
             bool badHDMI = false;
+
+            /* add ELD to monitoring */
+            m_controlMonitor.Add(strHwName, SND_CTL_ELEM_IFACE_PCM, dev, "ELD");
+
             if (!GetELD(hctl, dev, info, badHDMI))
               CLog::Log(LOGDEBUG, "CAESinkALSA - Unable to obtain ELD information for device \"%s\" (not supported by device, or kernel older than 3.2)",
                         device.c_str());
@@ -1619,5 +1627,6 @@ void CAESinkALSA::sndLibErrorHandler(const char *file, int line, const char *fun
 #if HAVE_LIBUDEV
 CALSADeviceMonitor CAESinkALSA::m_deviceMonitor; // ARGH
 #endif
+CALSAHControlMonitor CAESinkALSA::m_controlMonitor; // ARGH
 
 #endif
diff --git a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
index 54402f9..2059eaa 100644
--- a/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
+++ b/xbmc/cores/AudioEngine/Sinks/AESinkALSA.h
@@ -25,6 +25,7 @@
 #include "cores/AudioEngine/Interfaces/AESink.h"
 #include "cores/AudioEngine/Utils/AEDeviceInfo.h"
 #include "cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h"
+#include "cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h"
 #include <stdint.h>
 
 #define ALSA_PCM_NEW_HW_PARAMS_API
@@ -90,6 +91,7 @@ class CAESinkALSA : public IAESink
 #if HAVE_LIBUDEV
   static CALSADeviceMonitor m_deviceMonitor;
 #endif
+  static CALSAHControlMonitor m_controlMonitor;
 
   struct ALSAConfig
   {
diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
new file mode 100644
index 0000000..9b595ee
--- /dev/null
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
@@ -0,0 +1,173 @@
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "system.h"
+#ifdef HAS_ALSA
+
+#include "ALSAHControlMonitor.h"
+
+#include "AEFactory.h"
+#include "linux/FDEventMonitor.h"
+#include "utils/log.h"
+
+CALSAHControlMonitor::CALSAHControlMonitor()
+{
+}
+
+CALSAHControlMonitor::~CALSAHControlMonitor()
+{
+  Clear();
+}
+
+bool CALSAHControlMonitor::Add(const std::string& ctlHandleName,
+                               snd_ctl_elem_iface_t interface,
+                               unsigned int device,
+                               const std::string& name)
+{
+  snd_hctl_t *hctl = GetHandle(ctlHandleName);
+
+  if (!hctl)
+  {
+    return false;
+  }
+
+  snd_ctl_elem_id_t *id;
+
+  snd_ctl_elem_id_alloca(&id);
+
+  snd_ctl_elem_id_set_interface(id, interface);
+  snd_ctl_elem_id_set_name     (id, name.c_str());
+  snd_ctl_elem_id_set_device   (id, device);
+
+  snd_hctl_elem_t *elem = snd_hctl_find_elem(hctl, id);
+
+  if (!elem)
+  {
+    PutHandle(ctlHandleName);
+    return false;
+  }
+
+  snd_hctl_elem_set_callback(elem, HCTLCallback);
+
+  return true;
+}
+
+void CALSAHControlMonitor::Clear()
+{
+  Stop();
+
+  for (std::map<std::string, CTLHandle>::iterator it = m_ctlHandles.begin();
+       it != m_ctlHandles.end(); ++it)
+  {
+    snd_hctl_close(it->second.handle);
+  }
+  m_ctlHandles.clear();
+}
+
+void CALSAHControlMonitor::Start()
+{
+  assert(m_fdMonitorIds.size() == 0);
+
+  std::vector<struct pollfd> pollfds;
+  std::vector<CFDEventMonitor::MonitoredFD> monitoredFDs;
+
+  for (std::map<std::string, CTLHandle>::iterator it = m_ctlHandles.begin();
+       it != m_ctlHandles.end(); ++it)
+  {
+    pollfds.resize(snd_hctl_poll_descriptors_count(it->second.handle));
+    int fdcount = snd_hctl_poll_descriptors(it->second.handle, &pollfds[0], pollfds.size());
+
+    for (int j = 0; j < fdcount; ++j)
+    {
+      monitoredFDs.push_back(CFDEventMonitor::MonitoredFD(pollfds[j].fd,
+                                                          pollfds[j].events,
+                                                          FDEventCallback,
+                                                          it->second.handle));
+    }
+  }
+
+  g_fdEventMonitor.AddFDs(monitoredFDs, m_fdMonitorIds);
+}
+
+
+void CALSAHControlMonitor::Stop()
+{
+  g_fdEventMonitor.RemoveFDs(m_fdMonitorIds);
+  m_fdMonitorIds.clear();
+}
+
+int CALSAHControlMonitor::HCTLCallback(snd_hctl_elem_t *elem, unsigned int mask)
+{
+  /*
+   * Currently we just re-enumerate on any change.
+   * Custom callbacks for handling other control monitoring may be implemented when needed.
+   */
+  if (mask & SND_CTL_EVENT_MASK_VALUE)
+  {
+    CAEFactory::DeviceChange();
+  }
+
+  return 0;
+}
+
+void CALSAHControlMonitor::FDEventCallback(int id, int fd, short revents, void *data)
+{
+  /* Run ALSA event handling when the FD has events */
+  snd_hctl_t *hctl = (snd_hctl_t *)data;
+  snd_hctl_handle_events(hctl);
+}
+
+snd_hctl_t* CALSAHControlMonitor::GetHandle(const std::string& ctlHandleName)
+{
+  if (!m_ctlHandles.count(ctlHandleName))
+  {
+    snd_hctl_t *hctl;
+
+    if (snd_hctl_open(&hctl, ctlHandleName.c_str(), 0) != 0)
+    {
+        CLog::Log(LOGWARNING, "CALSAHControlMonitor::GetHandle - snd_hctl_open() failed for \"%s\"", ctlHandleName.c_str());
+        return NULL;
+    }
+    if (snd_hctl_load(hctl) != 0)
+    {
+      CLog::Log(LOGERROR, "CALSAHControlMonitor::GetHandle - snd_hctl_load() failed for \"%s\"", ctlHandleName.c_str());
+      snd_hctl_close(hctl);
+      return NULL;
+    }
+
+    snd_hctl_nonblock(hctl, 1);
+
+    m_ctlHandles[ctlHandleName] = CTLHandle(hctl);
+  }
+
+  m_ctlHandles[ctlHandleName].useCount++;
+  return m_ctlHandles[ctlHandleName].handle;
+}
+
+void CALSAHControlMonitor::PutHandle(const std::string& ctlHandleName)
+{
+  if (--m_ctlHandles[ctlHandleName].useCount == 0)
+  {
+    snd_hctl_close(m_ctlHandles[ctlHandleName].handle);
+    m_ctlHandles.erase(ctlHandleName);
+  }
+}
+
+
+#endif
diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h
new file mode 100644
index 0000000..56dfd50
--- /dev/null
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h
@@ -0,0 +1,69 @@
+#pragma once
+/*
+ *      Copyright (C) 2014 Team Kodi
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "system.h"
+#ifdef HAS_ALSA
+
+#include <string>
+#include <map>
+#include <vector>
+
+#include <alsa/asoundlib.h>
+
+class CALSAHControlMonitor
+{
+public:
+  CALSAHControlMonitor();
+  ~CALSAHControlMonitor();
+
+  bool Add(const std::string& ctlHandleName,
+           snd_ctl_elem_iface_t interface,
+           unsigned int device,
+           const std::string& name);
+
+  void Clear();
+
+  void Start();
+  void Stop();
+
+private:
+  static int HCTLCallback(snd_hctl_elem_t *elem, unsigned int mask);
+  static void FDEventCallback(int id, int fd, short revents, void *data);
+
+  snd_hctl_t* GetHandle(const std::string& ctlHandleName);
+  void PutHandle(const std::string& ctlHandleName);
+
+  struct CTLHandle
+  {
+    snd_hctl_t *handle;
+    int useCount;
+
+    CTLHandle(snd_hctl_t *handle_) : handle(handle_), useCount(0) {}
+    CTLHandle() : handle(NULL), useCount(0) {}
+  };
+
+  std::map<std::string, CTLHandle> m_ctlHandles;
+
+  std::vector<int> m_fdMonitorIds;
+};
+
+#endif
+

From b1c67c1a6448d05bb3393eeccb857a3ec71625b5 Mon Sep 17 00:00:00 2001
From: Anssi Hannula <anssi@xbmc.org>
Date: Sun, 2 Nov 2014 21:10:51 +0200
Subject: [PATCH 08/10] [AE] ALSA: Add more logging to device change triggers

---
 xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp   | 13 +++++++++++--
 xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp |  2 ++
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
index e3269ad..b0243b9 100644
--- a/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.cpp
@@ -113,12 +113,21 @@ void CALSADeviceMonitor::FDEventCallback(int id, int fd, short revents, void *da
     const char* action = udev_device_get_action(device);
     const char* soundInitialized = udev_device_get_property_value(device, "SOUND_INITIALIZED");
 
+    if (!action || !soundInitialized)
+      continue;
+
     /* cardX devices emit a "change" event when ready (i.e. all subdevices added) */
-    if (action && soundInitialized &&
-        (strcmp(action, "change") == 0 || strcmp(action, "remove") == 0))
+    if (strcmp(action, "change") == 0)
     {
+      CLog::Log(LOGDEBUG, "CALSADeviceMonitor - ALSA card added (\"%s\", \"%s\")", udev_device_get_syspath(device), udev_device_get_devpath(device));
       audioDevicesChanged = true;
     }
+    else if (strcmp(action, "remove") == 0)
+    {
+      CLog::Log(LOGDEBUG, "CALSADeviceMonitor - ALSA card removed");
+      audioDevicesChanged = true;
+    }
+
     udev_device_unref(device);
   }
 
diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
index 9b595ee..f9ca9ae 100644
--- a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
@@ -120,6 +120,8 @@ int CALSAHControlMonitor::HCTLCallback(snd_hctl_elem_t *elem, unsigned int mask)
    */
   if (mask & SND_CTL_EVENT_MASK_VALUE)
   {
+    CLog::Log(LOGDEBUG, "CALSAHControlMonitor - Monitored ALSA hctl value changed");
+
     CAEFactory::DeviceChange();
   }
 

From e83bc9308cd53fcfcef1053caa99797c8187a9b0 Mon Sep 17 00:00:00 2001
From: Anssi Hannula <anssi@xbmc.org>
Date: Tue, 4 Nov 2014 19:22:03 +0200
Subject: [PATCH 09/10] [AE] ALSA: Fix DeviceChange event triggered by
 enumeration

All hctl elements get an SND_CTL_EVENT_MASK_REMOVE event when the ctl
file descriptor is closed, which is done e.g. when re-enumerating
devices.

(SND_CTL_EVENT_MASK_REMOVE & SND_CTL_EVENT_MASK_VALUE) is true, and
therefore we re-triggered enumeration (depending a bit on timing).

Fix that by checking for the special _REMOVE value first and ignoring
those events.
---
 .../cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
index f9ca9ae..89a7585 100644
--- a/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
+++ b/xbmc/cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.cpp
@@ -114,14 +114,22 @@ void CALSAHControlMonitor::Stop()
 
 int CALSAHControlMonitor::HCTLCallback(snd_hctl_elem_t *elem, unsigned int mask)
 {
-  /*
-   * Currently we just re-enumerate on any change.
-   * Custom callbacks for handling other control monitoring may be implemented when needed.
-   */
+  /* _REMOVE is a special value instead of a bit and must be checked first */
+  if (mask == SND_CTL_EVENT_MASK_REMOVE)
+  {
+    /* Either the device was removed (which is handled in ALSADeviceMonitor instead)
+     * or snd_hctl_close() got called. */
+    return 0;
+  }
+
   if (mask & SND_CTL_EVENT_MASK_VALUE)
   {
     CLog::Log(LOGDEBUG, "CALSAHControlMonitor - Monitored ALSA hctl value changed");
 
+    /*
+     * Currently we just re-enumerate on any change.
+     * Custom callbacks for handling other control monitoring may be implemented when needed.
+     */
     CAEFactory::DeviceChange();
   }