Only try to load settings when the key exists.

Idea based on a patch from clsid.

3 files changed, 166 insertions, 165 deletions

diff --git a/decoder/LAVAudio/LAVAudio.cpp b/decoder/LAVAudio/LAVAudio.cpp
index ff9eebf3..45e92e9e 100644
--- a/decoder/LAVAudio/LAVAudio.cpp
+++ b/decoder/LAVAudio/LAVAudio.cpp
@@ -226,97 +226,97 @@ HRESULT CLAVAudio::LoadSettings()
   BYTE *pBuf = NULL;
 
   CRegistry reg = CRegistry(HKEY_CURRENT_USER, LAVC_AUDIO_REGISTRY_KEY, hr);
-  // We don't check if opening succeeded, because the read functions will set their hr accordingly anyway,
-  // and we need to fill the settings with defaults.
-  // ReadString returns an empty string in case of failure, so thats fine!
-  bFlag = reg.ReadDWORD(L"DRCEnabled", hr);
-  if (SUCCEEDED(hr)) m_settings.DRCEnabled = bFlag;
+  if (SUCCEEDED(hr)) {
+    bFlag = reg.ReadDWORD(L"DRCEnabled", hr);
+    if (SUCCEEDED(hr)) m_settings.DRCEnabled = bFlag;
 
-  dwVal = reg.ReadDWORD(L"DRCLevel", hr);
-  if (SUCCEEDED(hr)) m_settings.DRCLevel = (int)dwVal;
+    dwVal = reg.ReadDWORD(L"DRCLevel", hr);
+    if (SUCCEEDED(hr)) m_settings.DRCLevel = (int)dwVal;
 
-  // Deprecated format storage
-  pBuf = reg.ReadBinary(L"Formats", dwVal, hr);
-  if (SUCCEEDED(hr)) {
-    memcpy(&m_settings.bFormats, pBuf, min(dwVal, sizeof(m_settings.bFormats)));
-    SAFE_CO_FREE(pBuf);
-  }
+    // Deprecated format storage
+    pBuf = reg.ReadBinary(L"Formats", dwVal, hr);
+    if (SUCCEEDED(hr)) {
+      memcpy(&m_settings.bFormats, pBuf, min(dwVal, sizeof(m_settings.bFormats)));
+      SAFE_CO_FREE(pBuf);
+    }
 
-  // Deprecated bitstreaming storage
-  pBuf = reg.ReadBinary(L"Bitstreaming", dwVal, hr);
-  if (SUCCEEDED(hr)) {
-    memcpy(&m_settings.bBitstream, pBuf, min(dwVal, sizeof(m_settings.bBitstream)));
-    SAFE_CO_FREE(pBuf);
-  }
+    // Deprecated bitstreaming storage
+    pBuf = reg.ReadBinary(L"Bitstreaming", dwVal, hr);
+    if (SUCCEEDED(hr)) {
+      memcpy(&m_settings.bBitstream, pBuf, min(dwVal, sizeof(m_settings.bBitstream)));
+      SAFE_CO_FREE(pBuf);
+    }
 
-  bFlag = reg.ReadBOOL(L"DTSHDFraming", hr);
-  if (SUCCEEDED(hr)) m_settings.DTSHDFraming = bFlag;
+    bFlag = reg.ReadBOOL(L"DTSHDFraming", hr);
+    if (SUCCEEDED(hr)) m_settings.DTSHDFraming = bFlag;
 
-  bFlag = reg.ReadBOOL(L"AutoAVSync", hr);
-  if (SUCCEEDED(hr)) m_settings.AutoAVSync = bFlag;
+    bFlag = reg.ReadBOOL(L"AutoAVSync", hr);
+    if (SUCCEEDED(hr)) m_settings.AutoAVSync = bFlag;
 
-  bFlag = reg.ReadBOOL(L"ExpandMono", hr);
-  if (SUCCEEDED(hr)) m_settings.ExpandMono = bFlag;
+    bFlag = reg.ReadBOOL(L"ExpandMono", hr);
+    if (SUCCEEDED(hr)) m_settings.ExpandMono = bFlag;
 
-  bFlag = reg.ReadBOOL(L"Expand61", hr);
-  if (SUCCEEDED(hr)) m_settings.Expand61 = bFlag;
+    bFlag = reg.ReadBOOL(L"Expand61", hr);
+    if (SUCCEEDED(hr)) m_settings.Expand61 = bFlag;
 
-  bFlag = reg.ReadBOOL(L"OutputStandardLayout", hr);
-  if (SUCCEEDED(hr)) m_settings.OutputStandardLayout = bFlag;
+    bFlag = reg.ReadBOOL(L"OutputStandardLayout", hr);
+    if (SUCCEEDED(hr)) m_settings.OutputStandardLayout = bFlag;
 
-  bFlag = reg.ReadBOOL(L"Mixing", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingEnabled = bFlag;
+    bFlag = reg.ReadBOOL(L"Mixing", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingEnabled = bFlag;
 
-  dwVal = reg.ReadDWORD(L"MixingLayout", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingLayout = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingLayout", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingLayout = dwVal;
 
-  dwVal = reg.ReadDWORD(L"MixingFlags", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingFlags = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingFlags", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingFlags = dwVal;
 
-  dwVal = reg.ReadDWORD(L"MixingMode", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingMode = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingMode", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingMode = dwVal;
 
-  dwVal = reg.ReadDWORD(L"MixingCenterLevel", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingCenterLevel = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingCenterLevel", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingCenterLevel = dwVal;
 
-  dwVal = reg.ReadDWORD(L"MixingSurroundLevel", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingSurroundLevel = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingSurroundLevel", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingSurroundLevel = dwVal;
 
-  dwVal = reg.ReadDWORD(L"MixingLFELevel", hr);
-  if (SUCCEEDED(hr)) m_settings.MixingLFELevel = dwVal;
+    dwVal = reg.ReadDWORD(L"MixingLFELevel", hr);
+    if (SUCCEEDED(hr)) m_settings.MixingLFELevel = dwVal;
 
-  // Deprecated sample format storage
-  pBuf = reg.ReadBinary(L"SampleFormats", dwVal, hr);
-  if (SUCCEEDED(hr)) {
-    memcpy(&m_settings.bSampleFormats, pBuf, min(dwVal, sizeof(m_settings.bSampleFormats)));
-    SAFE_CO_FREE(pBuf);
-  }
+    // Deprecated sample format storage
+    pBuf = reg.ReadBinary(L"SampleFormats", dwVal, hr);
+    if (SUCCEEDED(hr)) {
+      memcpy(&m_settings.bSampleFormats, pBuf, min(dwVal, sizeof(m_settings.bSampleFormats)));
+      SAFE_CO_FREE(pBuf);
+    }
 
-  bFlag = reg.ReadBOOL(L"AudioDelayEnabled", hr);
-  if (SUCCEEDED(hr)) m_settings.AudioDelayEnabled = bFlag;
+    bFlag = reg.ReadBOOL(L"AudioDelayEnabled", hr);
+    if (SUCCEEDED(hr)) m_settings.AudioDelayEnabled = bFlag;
 
-  dwVal = reg.ReadDWORD(L"AudioDelay", hr);
-  if (SUCCEEDED(hr)) m_settings.AudioDelay = (int)dwVal;
+    dwVal = reg.ReadDWORD(L"AudioDelay", hr);
+    if (SUCCEEDED(hr)) m_settings.AudioDelay = (int)dwVal;
 
-  for (int i = 0; i < Bitstream_NB; ++i) {
-    std::wstring key = std::wstring(L"Bitstreaming_") + std::wstring(bitstreamingCodecs[i]);
-    bFlag = reg.ReadBOOL(key.c_str(), hr);
-    if (SUCCEEDED(hr)) m_settings.bBitstream[i] = bFlag;
-  }
+    for (int i = 0; i < Bitstream_NB; ++i) {
+      std::wstring key = std::wstring(L"Bitstreaming_") + std::wstring(bitstreamingCodecs[i]);
+      bFlag = reg.ReadBOOL(key.c_str(), hr);
+      if (SUCCEEDED(hr)) m_settings.bBitstream[i] = bFlag;
+    }
 
-  for (int i = 0; i < SampleFormat_Bitstream; ++i) {
-    std::wstring key = std::wstring(L"SampleFormat_") + std::wstring(sampleFormats[i]);
-    bFlag = reg.ReadBOOL(key.c_str(), hr);
-    if (SUCCEEDED(hr)) m_settings.bSampleFormats[i] = bFlag;
+    for (int i = 0; i < SampleFormat_Bitstream; ++i) {
+      std::wstring key = std::wstring(L"SampleFormat_") + std::wstring(sampleFormats[i]);
+      bFlag = reg.ReadBOOL(key.c_str(), hr);
+      if (SUCCEEDED(hr)) m_settings.bSampleFormats[i] = bFlag;
+    }
   }
 
   CRegistry regF = CRegistry(HKEY_CURRENT_USER, LAVC_AUDIO_REGISTRY_KEY_FORMATS, hr);
-
-  for (int i = 0; i < Codec_AudioNB; ++i) {
-    const codec_config_t *info = get_codec_config((LAVAudioCodec)i);
-    ATL::CA2W name(info->name);
-    bFlag = regF.ReadBOOL(name, hr);
-    if (SUCCEEDED(hr)) m_settings.bFormats[i] = bFlag;
+  if (SUCCEEDED(hr)) {
+    for (int i = 0; i < Codec_AudioNB; ++i) {
+      const codec_config_t *info = get_codec_config((LAVAudioCodec)i);
+      ATL::CA2W name(info->name);
+      bFlag = regF.ReadBOOL(name, hr);
+      if (SUCCEEDED(hr)) m_settings.bFormats[i] = bFlag;
+    }
   }
 
   return S_OK;
diff --git a/decoder/LAVVideo/LAVVideo.cpp b/decoder/LAVVideo/LAVVideo.cpp
index a0322557..814f9096 100644
--- a/decoder/LAVVideo/LAVVideo.cpp
+++ b/decoder/LAVVideo/LAVVideo.cpp
@@ -193,95 +193,96 @@ HRESULT CLAVVideo::LoadSettings()
   DWORD dwVal;
 
   CRegistry reg = CRegistry(HKEY_CURRENT_USER, LAVC_VIDEO_REGISTRY_KEY, hr);
-  // We don't check if opening succeeded, because the read functions will set their hr accordingly anyway,
-  // and we need to fill the settings with defaults.
-  // ReadString returns an empty string in case of failure, so thats fine!
-
-  dwVal = reg.ReadDWORD(L"StreamAR", hr);
-  if (SUCCEEDED(hr)) m_settings.StreamAR = dwVal;
+  if (SUCCEEDED(hr)) {
+    dwVal = reg.ReadDWORD(L"StreamAR", hr);
+    if (SUCCEEDED(hr)) m_settings.StreamAR = dwVal;
 
-  dwVal = reg.ReadDWORD(L"NumThreads", hr);
-  if (SUCCEEDED(hr)) m_settings.NumThreads = dwVal;
+    dwVal = reg.ReadDWORD(L"NumThreads", hr);
+    if (SUCCEEDED(hr)) m_settings.NumThreads = dwVal;
 
-  dwVal = reg.ReadDWORD(L"DeintFieldOrder", hr);
-  if (SUCCEEDED(hr)) m_settings.DeintFieldOrder = dwVal;
+    dwVal = reg.ReadDWORD(L"DeintFieldOrder", hr);
+    if (SUCCEEDED(hr)) m_settings.DeintFieldOrder = dwVal;
 
-  bFlag = reg.ReadBOOL(L"DeintAggressive", hr);
-  if (SUCCEEDED(hr)) m_settings.DeintAggressive = bFlag;
+    bFlag = reg.ReadBOOL(L"DeintAggressive", hr);
+    if (SUCCEEDED(hr)) m_settings.DeintAggressive = bFlag;
 
-  bFlag = reg.ReadBOOL(L"DeintForce", hr);
-  if (SUCCEEDED(hr)) m_settings.DeintForce = bFlag;
+    bFlag = reg.ReadBOOL(L"DeintForce", hr);
+    if (SUCCEEDED(hr)) m_settings.DeintForce = bFlag;
 
-  dwVal = reg.ReadDWORD(L"RGBRange", hr);
-  if (SUCCEEDED(hr)) m_settings.RGBRange = dwVal;
+    dwVal = reg.ReadDWORD(L"RGBRange", hr);
+    if (SUCCEEDED(hr)) m_settings.RGBRange = dwVal;
 
-  dwVal = reg.ReadDWORD(L"SWDeintMode", hr);
-  if (SUCCEEDED(hr)) m_settings.SWDeintMode = dwVal;
+    dwVal = reg.ReadDWORD(L"SWDeintMode", hr);
+    if (SUCCEEDED(hr)) m_settings.SWDeintMode = dwVal;
 
-  dwVal = reg.ReadDWORD(L"SWDeintOutput", hr);
-  if (SUCCEEDED(hr)) m_settings.SWDeintOutput = dwVal;
+    dwVal = reg.ReadDWORD(L"SWDeintOutput", hr);
+    if (SUCCEEDED(hr)) m_settings.SWDeintOutput = dwVal;
 
-  bFlag = reg.ReadBOOL(L"DeintTreatAsProgressive", hr);
-  if (SUCCEEDED(hr)) m_settings.DeintTreatAsProgressive = bFlag;
+    bFlag = reg.ReadBOOL(L"DeintTreatAsProgressive", hr);
+    if (SUCCEEDED(hr)) m_settings.DeintTreatAsProgressive = bFlag;
 
-  dwVal = reg.ReadDWORD(L"DitherMode", hr);
-  if (SUCCEEDED(hr)) m_settings.DitherMode = dwVal;
+    dwVal = reg.ReadDWORD(L"DitherMode", hr);
+    if (SUCCEEDED(hr)) m_settings.DitherMode = dwVal;
 
-  bFlag = reg.ReadBOOL(L"DVDVideo", hr);
-  if (SUCCEEDED(hr)) m_settings.bDVDVideo = bFlag;
+    bFlag = reg.ReadBOOL(L"DVDVideo", hr);
+    if (SUCCEEDED(hr)) m_settings.bDVDVideo = bFlag;
 
-  bFlag = reg.ReadBOOL(L"MSWMV9DMO", hr);
-  if (SUCCEEDED(hr)) m_settings.bMSWMV9DMO = bFlag;
+    bFlag = reg.ReadBOOL(L"MSWMV9DMO", hr);
+    if (SUCCEEDED(hr)) m_settings.bMSWMV9DMO = bFlag;
+  }
 
   CRegistry regF = CRegistry(HKEY_CURRENT_USER, LAVC_VIDEO_REGISTRY_KEY_FORMATS, hr);
-
-  for (int i = 0; i < Codec_VideoNB; ++i) {
-    const codec_config_t *info = get_codec_config((LAVVideoCodec)i);
-    ATL::CA2W name(info->name);
-    bFlag = regF.ReadBOOL(name, hr);
-    if (SUCCEEDED(hr)) m_settings.bFormats[i] = bFlag;
+  if (SUCCEEDED(hr)) {
+    for (int i = 0; i < Codec_VideoNB; ++i) {
+      const codec_config_t *info = get_codec_config((LAVVideoCodec)i);
+      ATL::CA2W name(info->name);
+      bFlag = regF.ReadBOOL(name, hr);
+      if (SUCCEEDED(hr)) m_settings.bFormats[i] = bFlag;
+    }
   }
 
   CRegistry regP = CRegistry(HKEY_CURRENT_USER, LAVC_VIDEO_REGISTRY_KEY_OUTPUT, hr);
-
-  for (int i = 0; i < LAVOutPixFmt_NB; ++i) {
-    bFlag = regP.ReadBOOL(pixFmtSettingsMap[i], hr);
-    if (SUCCEEDED(hr)) m_settings.bPixFmts[i] = bFlag;
+  if (SUCCEEDED(hr)) {
+    for (int i = 0; i < LAVOutPixFmt_NB; ++i) {
+      bFlag = regP.ReadBOOL(pixFmtSettingsMap[i], hr);
+      if (SUCCEEDED(hr)) m_settings.bPixFmts[i] = bFlag;
+    }
+    // Force disable, for future use
+    m_settings.bPixFmts[LAVOutPixFmt_YV16] = FALSE;
   }
-  // Force disable, for future use
-  m_settings.bPixFmts[LAVOutPixFmt_YV16] = FALSE;
 
   CRegistry regHW = CRegistry(HKEY_CURRENT_USER, LAVC_VIDEO_REGISTRY_KEY_HWACCEL, hr);
+  if (SUCCEEDED(hr)) {
+    dwVal = regHW.ReadDWORD(L"HWAccel", hr);
+    if (SUCCEEDED(hr)) m_settings.HWAccel = dwVal;
 
-  dwVal = regHW.ReadDWORD(L"HWAccel", hr);
-  if (SUCCEEDED(hr)) m_settings.HWAccel = dwVal;
-
-  bFlag = regHW.ReadBOOL(L"h264", hr);
-  if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_H264] = bFlag;
+    bFlag = regHW.ReadBOOL(L"h264", hr);
+    if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_H264] = bFlag;
 
-  bFlag = regHW.ReadBOOL(L"vc1", hr);
-  if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_VC1] = bFlag;
+    bFlag = regHW.ReadBOOL(L"vc1", hr);
+    if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_VC1] = bFlag;
 
-  bFlag = regHW.ReadBOOL(L"mpeg2", hr);
-  if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG2] = bFlag;
+    bFlag = regHW.ReadBOOL(L"mpeg2", hr);
+    if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG2] = bFlag;
 
-  bFlag = regHW.ReadBOOL(L"mpeg4", hr);
-  if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG4] = bFlag;
+    bFlag = regHW.ReadBOOL(L"mpeg4", hr);
+    if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG4] = bFlag;
 
-  bFlag = regHW.ReadBOOL(L"dvd", hr);
-  if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG2DVD] = bFlag;
+    bFlag = regHW.ReadBOOL(L"dvd", hr);
+    if (SUCCEEDED(hr)) m_settings.bHWFormats[HWCodec_MPEG2DVD] = bFlag;
 
-  dwVal = regHW.ReadDWORD(L"HWResFlags", hr);
-  if (SUCCEEDED(hr)) m_settings.HWAccelResFlags = dwVal;
+    dwVal = regHW.ReadDWORD(L"HWResFlags", hr);
+    if (SUCCEEDED(hr)) m_settings.HWAccelResFlags = dwVal;
 
-  dwVal = regHW.ReadDWORD(L"HWDeintMode", hr);
-  if (SUCCEEDED(hr)) m_settings.HWDeintMode = dwVal;
+    dwVal = regHW.ReadDWORD(L"HWDeintMode", hr);
+    if (SUCCEEDED(hr)) m_settings.HWDeintMode = dwVal;
 
-  dwVal = regHW.ReadDWORD(L"HWDeintOutput", hr);
-  if (SUCCEEDED(hr)) m_settings.HWDeintOutput = dwVal;
+    dwVal = regHW.ReadDWORD(L"HWDeintOutput", hr);
+    if (SUCCEEDED(hr)) m_settings.HWDeintOutput = dwVal;
 
-  bFlag = regHW.ReadBOOL(L"HWDeintHQ", hr);
-  if (SUCCEEDED(hr)) m_settings.HWDeintHQ = bFlag;
+    bFlag = regHW.ReadBOOL(L"HWDeintHQ", hr);
+    if (SUCCEEDED(hr)) m_settings.HWDeintHQ = bFlag;
+  }
 
   return S_OK;
 }
diff --git a/demuxer/LAVSplitter/LAVSplitter.cpp b/demuxer/LAVSplitter/LAVSplitter.cpp
index 76d66991..7c6ebc8f 100644
--- a/demuxer/LAVSplitter/LAVSplitter.cpp
+++ b/demuxer/LAVSplitter/LAVSplitter.cpp
@@ -163,55 +163,55 @@ STDMETHODIMP CLAVSplitter::LoadSettings()
   std::wstring strVal;
 
   CRegistry reg = CRegistry(HKEY_CURRENT_USER, LAVF_REGISTRY_KEY, hr);
-  // We don't check if opening succeeded, because the read functions will set their hr accordingly anyway,
-  // and we need to fill the settings with defaults.
-
-  // Language preferences
-  strVal = reg.ReadString(L"prefAudioLangs", hr);
-  if (SUCCEEDED(hr)) m_settings.prefAudioLangs = strVal;
+  if (SUCCEEDED(hr)) {
+    // Language preferences
+    strVal = reg.ReadString(L"prefAudioLangs", hr);
+    if (SUCCEEDED(hr)) m_settings.prefAudioLangs = strVal;
 
-  strVal = reg.ReadString(L"prefSubLangs", hr);
-  if (SUCCEEDED(hr)) m_settings.prefSubLangs = strVal;
+    strVal = reg.ReadString(L"prefSubLangs", hr);
+    if (SUCCEEDED(hr)) m_settings.prefSubLangs = strVal;
 
-  strVal = reg.ReadString(L"subtitleAdvanced", hr);
-  if (SUCCEEDED(hr)) m_settings.subtitleAdvanced = strVal;
+    strVal = reg.ReadString(L"subtitleAdvanced", hr);
+    if (SUCCEEDED(hr)) m_settings.subtitleAdvanced = strVal;
 
-  // Subtitle mode, defaults to all subtitles
-  dwVal = reg.ReadDWORD(L"subtitleMode", hr);
-  if (SUCCEEDED(hr)) m_settings.subtitleMode = (LAVSubtitleMode)dwVal;
+    // Subtitle mode, defaults to all subtitles
+    dwVal = reg.ReadDWORD(L"subtitleMode", hr);
+    if (SUCCEEDED(hr)) m_settings.subtitleMode = (LAVSubtitleMode)dwVal;
 
-  bFlag = reg.ReadBOOL(L"PGSForcedStream", hr);
-  if (SUCCEEDED(hr)) m_settings.PGSForcedStream = bFlag;
+    bFlag = reg.ReadBOOL(L"PGSForcedStream", hr);
+    if (SUCCEEDED(hr)) m_settings.PGSForcedStream = bFlag;
 
-  bFlag = reg.ReadBOOL(L"PGSOnlyForced", hr);
-  if (SUCCEEDED(hr)) m_settings.PGSOnlyForced = bFlag;
+    bFlag = reg.ReadBOOL(L"PGSOnlyForced", hr);
+    if (SUCCEEDED(hr)) m_settings.PGSOnlyForced = bFlag;
 
-  dwVal = reg.ReadDWORD(L"vc1TimestampMode", hr);
-  if (SUCCEEDED(hr)) m_settings.vc1Mode = dwVal;
+    dwVal = reg.ReadDWORD(L"vc1TimestampMode", hr);
+    if (SUCCEEDED(hr)) m_settings.vc1Mode = dwVal;
 
-  bFlag = reg.ReadDWORD(L"substreams", hr);
-  if (SUCCEEDED(hr)) m_settings.substreams = bFlag;
+    bFlag = reg.ReadDWORD(L"substreams", hr);
+    if (SUCCEEDED(hr)) m_settings.substreams = bFlag;
 
-  bFlag = reg.ReadDWORD(L"videoParsing", hr);
-  if (SUCCEEDED(hr)) m_settings.videoParsing = bFlag;
+    bFlag = reg.ReadDWORD(L"videoParsing", hr);
+    if (SUCCEEDED(hr)) m_settings.videoParsing = bFlag;
 
-  bFlag = reg.ReadDWORD(L"StreamSwitchRemoveAudio", hr);
-  if (SUCCEEDED(hr)) m_settings.StreamSwitchRemoveAudio = bFlag;
+    bFlag = reg.ReadDWORD(L"StreamSwitchRemoveAudio", hr);
+    if (SUCCEEDED(hr)) m_settings.StreamSwitchRemoveAudio = bFlag;
 
-  bFlag = reg.ReadDWORD(L"ImpairedAudio", hr);
-  if (SUCCEEDED(hr)) m_settings.ImpairedAudio = bFlag;
+    bFlag = reg.ReadDWORD(L"ImpairedAudio", hr);
+    if (SUCCEEDED(hr)) m_settings.ImpairedAudio = bFlag;
 
-  dwVal = reg.ReadDWORD(L"QueueMaxSize", hr);
-  if (SUCCEEDED(hr)) m_settings.QueueMaxSize = dwVal;
+    dwVal = reg.ReadDWORD(L"QueueMaxSize", hr);
+    if (SUCCEEDED(hr)) m_settings.QueueMaxSize = dwVal;
+  }
 
   CRegistry regF = CRegistry(HKEY_CURRENT_USER, LAVF_REGISTRY_KEY_FORMATS, hr);
-
-  WCHAR wBuffer[80];
-  std::set<FormatInfo>::iterator it;
-  for (it = m_InputFormats.begin(); it != m_InputFormats.end(); ++it) {
-    MultiByteToWideChar(CP_UTF8, 0, it->strName, -1, wBuffer, 80);
-    bFlag = regF.ReadBOOL(wBuffer, hr);
-    if (SUCCEEDED(hr)) m_settings.formats[std::string(it->strName)] = bFlag;
+  if (SUCCEEDED(hr)) {
+    WCHAR wBuffer[80];
+    std::set<FormatInfo>::iterator it;
+    for (it = m_InputFormats.begin(); it != m_InputFormats.end(); ++it) {
+      MultiByteToWideChar(CP_UTF8, 0, it->strName, -1, wBuffer, 80);
+      bFlag = regF.ReadBOOL(wBuffer, hr);
+      if (SUCCEEDED(hr)) m_settings.formats[std::string(it->strName)] = bFlag;
+    }
   }
 
   return S_OK;