//------------------------------------------------------------------------------
  // File: MultiVMR9.cpp
  //
  // Desc: DirectShow sample code - Implementation of DLL Exports.
  //
  // Copyright (c) Microsoft Corporation.  All rights reserved.
  //------------------------------------------------------------------------------
  
  include <stdafx.h>
  include <resource.h>
  include <MultiVMR9.h>
  
  include <stdio.h>
  include <tchar.h>
  
  include <Wizard.h>
  include <RenderEngine.h>
  include <UILayer.h>
  include <MixerControl.h>
  
  HINSTANCE g_hInst = NULL;
  
  class CCFMultiVMR9Wizard;
  class CCFMultiVMR9RenderEngine;
  class CCFMultiVMR9UILayer;
  class CCFMultiVMR9MixerControl;
  
  static CCFMultiVMR9Wizard       g_WizardFactory;
  static CCFMultiVMR9RenderEngine g_RenderEngineFactory;
  static CCFMultiVMR9UILayer      g_UILayerFactory;
  static CCFMultiVMR9MixerControl g_MixerControlFactory;
  
  // the com module's lock count + object count
  long g_CountWizard = 0; 
  long g_CountRenderEngine = 0; 
  long g_CountUILayer = 0; 
  long g_CountMixerControl = 0; 
  
  // forward declarations
  void MultiVMRRegisterClass( const CLSID& clsid, TCHAR *achClassName, BOOL bRegister);
  LONG recursiveDeleteKey(HKEY hKeyParent, TCHAR* achKeyChild);
  
  // DLL Entry Point
  BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
  {
      if (DLL_PROCESS_ATTACH == dwReason )
      {
          g_hInst = hInstance;
      }
      return(TRUE);
  }
  
  //
  // stub entry points
  //
  
  STDAPI
  DllRegisterServer( void )
  {
      // now go register components; they are in HKEY_CLASSES_ROOT\CLSID{uuid}
      MultiVMRRegisterClass( CLSID_MultiVMR9Wizard,       TEXT("MultiVMR9 Wizard"), TRUE);
      MultiVMRRegisterClass( CLSID_MultiVMR9RenderEngine, TEXT("MultiVMR9 Render Engine"), TRUE);
      MultiVMRRegisterClass( CLSID_MultiVMR9UILayer,      TEXT("MultiVMR9 UI Layer"), TRUE);
      MultiVMRRegisterClass( CLSID_MultiVMR9MixerControl, TEXT("MultiVMR9 Mixer Control"), TRUE);
  
      return S_OK;
  }
  
  STDAPI
  DllUnregisterServer( void )
  {
      // now go register components; they are in HKEY_CLASSES_ROOT\CLSID{uuid}
      MultiVMRRegisterClass( CLSID_MultiVMR9Wizard,       TEXT("MultiVMR9 Wizard"), FALSE);
      MultiVMRRegisterClass( CLSID_MultiVMR9RenderEngine, TEXT("MultiVMR9 Render Engine"), FALSE);
      MultiVMRRegisterClass( CLSID_MultiVMR9UILayer,      TEXT("MultiVMR9 UI Layer"), FALSE);
      MultiVMRRegisterClass( CLSID_MultiVMR9MixerControl, TEXT("MultiVMR9 Mixer Control"), FALSE);
  
      return S_OK;
  }
  
  STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv)
  {
      if (CLSID_MultiVMR9Wizard == rclsid )
      {
          return g_WizardFactory.QueryInterface(riid, ppv);
      }
      else if( CLSID_MultiVMR9RenderEngine == rclsid )
      {
          return g_RenderEngineFactory.QueryInterface(riid, ppv);
      }
      else if( CLSID_MultiVMR9UILayer == rclsid )
      {
          return g_UILayerFactory.QueryInterface(riid, ppv);
      }
      else if( CLSID_MultiVMR9MixerControl == rclsid )
      {
          return g_MixerControlFactory.QueryInterface(riid, ppv);
      }
      else
      {
          *ppv = NULL;
          return CLASS_E_CLASSNOTAVAILABLE;
      }
  }
  
  STDAPI DllCanUnloadNow(void)
  {
      HRESULT hr = S_FALSE;
  
      if( 0 == g_CountWizard &&
          0 == g_CountRenderEngine &&
          0 == g_CountUILayer &&
          0 == g_CountMixerControl )
      {
          hr = S_OK;
      }
      return hr;
  }
  
  //
  // Add entry to the registry about CLSID object 
  //
  void MultiVMRRegisterClass( 
                             const CLSID& clsid, 
                             TCHAR *achClassName,
                             BOOL bRegister)
  {
      HRESULT hr = S_OK;
      TCHAR achModule[MAX_PATH];
      WCHAR wcModule[MAX_PATH];
      WCHAR wcKey[MAX_PATH];
      TCHAR achKey[MAX_PATH];
      TCHAR achThreadingModel[] = TEXT("Both");
      long err = 0;
      LPOLESTR wcCLSID = NULL;
      HKEY hKey = NULL;
      HKEY hSubKey = NULL;
  
      GetModuleFileName( g_hInst, achModule, sizeof(achModule) );
  
  ifdef UNICODE
      wcscpy( wcModule, achModule );
  else
      MultiByteToWideChar(CP_ACP, 0, achModule, -1, wcModule, MAX_PATH); 
  endif
  
      hr = StringFromCLSID(clsid, &wcCLSID);
  
      wcscpy( wcKey, L"CLSID\\");
      wcscat( wcKey, wcCLSID);
  
  ifdef UNICODE
      _tcscpy( achKey, wcKey);
  else
      WideCharToMultiByte(CP_ACP, 0, wcKey, -1, achKey, MAX_PATH, 0, 0);
  endif
  
      // first, delete wcKey if it exists
      err = recursiveDeleteKey( HKEY_CLASSES_ROOT, achKey);
  
      if( bRegister )
      {
          // create new key
          err = RegCreateKeyEx(   HKEY_CLASSES_ROOT,
                                  achKey, 
                                  NULL, 
                                  NULL, 
                                  REG_OPTION_NON_VOLATILE, 
                                  KEY_ALL_ACCESS, 
                                  NULL, 
                                  &hKey, 
                                  NULL);
          if (ERROR_SUCCESS == err)
          {
              err = RegSetValueEx( hKey, NULL, 0, REG_SZ,(BYTE *)achClassName, 
                                      sizeof(TCHAR) * ( _tcslen(achClassName)+1));
              err = RegCreateKeyEx(   hKey, 
                                      TEXT("InprocServer32"), 
                                      NULL,
                                      NULL,
                                      REG_OPTION_NON_VOLATILE, 
                                      KEY_ALL_ACCESS, 
                                      NULL, 
                                      &hSubKey, 
                                      NULL);
              if( ERROR_SUCCESS == err)
              {
                  err = RegSetValueEx( hSubKey, NULL, 0, REG_SZ,(BYTE *)achModule, 
                                      sizeof(TCHAR) * ( _tcslen(achModule)+1));
                  err = RegSetValueEx( hSubKey, TEXT("ThreadingModel"), 0, REG_SZ,(BYTE *)achThreadingModel, 
                                      sizeof(TCHAR) * ( _tcslen(achThreadingModel)+1));
                  RegCloseKey( hSubKey );
              }
              RegCloseKey( hKey );
          }
      }
      CoTaskMemFree(wcCLSID);
  }
  
  //
  // Delete a key and all of its descendents.
  //
  LONG recursiveDeleteKey(HKEY hKeyParent,     // Parent of key to delete
                          TCHAR* achKeyChild)  // Key to delete
  {
      // Open the child.
      HKEY hKeyChild;
      LONG lRes = RegOpenKeyEx(hKeyParent, achKeyChild, 0,
                                KEY_ALL_ACCESS, &hKeyChild);
      if (lRes != ERROR_SUCCESS)
      {
          return lRes;
      }
  
      // Enumerate all of the decendents of this child.
      FILETIME time;
      TCHAR achBuffer[256];
      DWORD dwSize = 256;
  
      while (RegEnumKeyEx(hKeyChild, 0, achBuffer, &dwSize, NULL,
             NULL, NULL, &time) == ERROR_SUCCESS)
      {
          // Delete the decendents of this child.
          lRes = recursiveDeleteKey(hKeyChild, achBuffer);
          if (lRes != ERROR_SUCCESS)
          {
              // Cleanup before exiting.
              RegCloseKey(hKeyChild);
              return lRes;
          }
          dwSize = 256;
      }
  
      // Close the child.
      RegCloseKey(hKeyChild);
  
      // Delete this child.
      return RegDeleteKey(hKeyParent, achKeyChild);
  }
  
  ifdef _DEBUG
      void DbgMsg( char* szMessage, ... )
      {
          char szFullMessage[MAX_PATH];
          char szFormatMessage[MAX_PATH];
  
          // format message
          va_list ap;
          va_start(ap, szMessage);
          _vsnprintf( szFormatMessage, MAX_PATH, szMessage, ap);
          va_end(ap);
          strncat( szFormatMessage, "\n", MAX_PATH);
          strcpy( szFullMessage, "~*~*~*~*~*~ ");
          strcat( szFullMessage, szFormatMessage );
          OutputDebugStringA( szFullMessage );
      }
  else
      void DbgMsg( char* szMessage, ... ){;}
  endif