开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
ddpdb.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：49k
源码类别：

Symbian

开发平台：

C/C++

ddpdb.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /* Windows include files: */
  37. #include <windows.h>
  38. #include <regstr.h>
  39. #include <ddraw.h>
  41. #ifdef IMPORT
  42. #include <initguid.h>
  43. #endif
  45. /* standard libraries: */
  46. #include <stdio.h>
  47. #include <sys/types.h>
  48. #include <sys/stat.h>
  49. #include <string.h>
  51. /* our headers: */
  52. #include "hxdx5032.h"   // for win95 driver info in CFullScreenInfo
  54. #include "ddpdb.h"
  55. #include "colormap.h"
  56. #include "hxdllldr.h"
  58. #define F(cid)          (1U << (cid))   /* converts CID into a bitmask  */
  59. #define MAX_BUF         512
  60. #define ENUM_MAX        6
  62. /*
  63.  * DirectDraw profiles:
  64.  */
  65. #define DDPDB_MAGIC     "DDPDB"
  66. #define DDPDB_VERSION   0x100
  67. #define MAXPROFILES     256
  69. static struct
  70. {
  71.     char            szMagic[8];                 /* some identifier      */
  72.     DWORD           dwVersion;                  /* database version     */
  73.     DWORD           dwNumProfiles;              /* # of records         */
  74.     DDDEVICEPROFILE ddProfiles[MAXPROFILES];    /* data                 */
  76. } DDPDB =
  77. {
  78.     DDPDB_MAGIC,
  79.     DDPDB_VERSION,
  80.     30,  /* # of profiles !!!!!!!!! */
  81.     {{
  82.         VER_PLATFORM_WIN32_WINDOWS,
  83.         {"ATI Rage II+ PCI (ati_m64)", "ati_m64.drv", 0x6b8,0x4000a,
  84.         0x1002, 0x4755, 0x0, 0x9a5b,
  85.         {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  86.         /* buggy driver... do NOT use overlays !!!: */
  87.         {0, 0, 0, 0, 0},
  88.         /* blits (use YUVs only !!!): */
  89.         {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  90.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  91.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  92.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  93.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY)}
  94.     },
  95.     {
  96. VER_PLATFORM_WIN32_WINDOWS,
  97. {"RAGE PRO TURBO AGP 2X (English)",
  98.  "macxdd32.dll",
  99.  0x10937,0x4000a,
  100.  0x1002, 0x4742, 0x47421002, 0x5c, 
  101.  {0xd7b71ee2,0x402,0x11cf,{0x85,0x7a,0x43,0x67,0xf9,0xc2,0xc9,0x35}}},
  102.         /* do NOT use overlays !!!: */
  103.         {0, 0, 0, 0, 0},
  104.         /* no blits either: */
  105.         {0, 0, 0, 0, 0}
  106.     },
  107.      {
  108.          VER_PLATFORM_WIN32_NT,
  109.          {"1002-4C46-03",
  110.           "ati2dvai.dll",
  111.           0x10426,0x5000c,
  112.           0x3320334d, 0x7a484d33, 0x50474128, 0x400029,
  113.           {0x800,0x4,0x0,{0x48,0x7,0x13,0x0,0xffffffd2,0x2c,0x40,0x0}}},
  114.          /* do NOT use overlays !!!: */
  115.          {0, 0, 0, 0, 0},
  116.          /* no blits either: */
  117.          {0, 0, 0, 0, 0}
  118.     },
  119.     {
  120.         VER_PLATFORM_WIN32_WINDOWS,
  121.         {"Matrox Millennium G200 AGP", "MGAXDD32.DLL", 0x1100e,0x4000a, 0x102B, 0x521, 0, 0,
  122.         {0xd7b71ecb,0x4661,0x11cf,{0xbe,0x73,0x01,0x20,0xa5,0xc2,0xc9,0x35}}},
  123.         /* overlays (use YUVs only): */
  124.         {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  125.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  126.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  127.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  128.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY)},
  129.         /* blits (use YUVs & matching RGBs): */
  130.         {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB32),
  131.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB24),
  132.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB565),
  133.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB555),
  134.         F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB8)}
  135.     },
  136.     {
  137.         VER_PLATFORM_WIN32_NT,
  138.         {"Matrox Millennium G200 AGP", "mga64.dll", 0x0,0x40000,
  139.         /* MGA-G200 B8 R1: */ 0x2d41474d, 0x30303247, 0x20384220, 0x03152, {0,0,0,{0,0,0,0,0,0,0,0}}},
  140.         /* do NOT use overlays !!!: */
  141.         {0, 0, 0, 0, 0},
  142.         /* blits (use YUY2s & matching RGBs only): */
  143.         {F(CID_YUY2) + F(CID_RGB32),
  144.          F(CID_YUY2) + F(CID_RGB24),
  145.          F(CID_YUY2) + F(CID_RGB565),
  146.          F(CID_YUY2) + F(CID_RGB555),
  147.          F(CID_YUY2) + F(CID_RGB8)}
  148.     },
  149.     {
  150.         VER_PLATFORM_WIN32_NT,
  151.         {"Matrox Millennium G200 AGP", "tsirchnl.dll", 0xc9,0x70008,
  152.         0x2d41474d, 0x30303247, 0x20384220, 0x4b003152,
  153.         {0x4f4e4d4c,0x5150,0x5352,{0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b}}},
  154.         /* do NOT use overlays !!!: */
  155.         {0, 0, 0, 0, 0},
  156.         /* blits (use YUY2s & matching RGBs only): */
  157.         {F(CID_YUY2) + F(CID_RGB32),
  158.          F(CID_YUY2) + F(CID_RGB24),
  159.          F(CID_YUY2) + F(CID_RGB565),
  160.          F(CID_YUY2) + F(CID_RGB555),
  161.          F(CID_YUY2) + F(CID_RGB8)}
  162.     },
  163.     {
  164.         VER_PLATFORM_WIN32_WINDOWS,
  165.         {"Matrox Millennium II PowerDesk", "MGAXDD32.DLL", 0x10ee2,0x4000a,
  166.         0x102b, 0x51b, 0x0, 0x0,
  167.         {0xd7b71ecb,0x465b,0x11cf,{0x52,0x6d,0x1,0x20,0xa5,0xc2,0xc9,0x35}}},
  168.         /* does not have overlays... */
  169.         {0, 0, 0, 0, 0},
  170.         /* blits (use YUY2s only): */
  171.         {F(CID_YUY2),
  172.          F(CID_YUY2),
  173.          F(CID_YUY2),
  174.          F(CID_YUY2),
  175.          F(CID_YUY2)}
  176.     },
  177.     {
  178.         VER_PLATFORM_WIN32_WINDOWS,
  179.         {"Matrox Millennium II PowerDesk", "MGAXDD32.DLL", 0xe2e,0x40003,
  180.         0x102b, 0x51b, 0x0, 0x0,
  181.         {0xd7b71ecb,0x465b,0x11cf,{0x9e,0x6d,0x0,0x20,0xac,0xc2,0xc9,0x35}}},
  182.         /* does not have overlays... */
  183.         {0, 0, 0, 0, 0},
  184.         /* blits (use YUY2s only): */
  185.         {F(CID_YUY2),
  186.          F(CID_YUY2),
  187.          F(CID_YUY2),
  188.          F(CID_YUY2),
  189.          F(CID_YUY2)}
  190.     },
  191.     {
  192.         VER_PLATFORM_WIN32_WINDOWS,
  193.         {"Matrox Millennium II PCI", "mgapdx64.drv", 0x110b8,0x4000a,
  194.         0x102b, 0x51b, 0x0, 0x25b,
  195.         {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  196.         /* does not have overlays... */
  197.         {0, 0, 0, 0, 0},
  198.         /* blits (use YUY2s only): */
  199.         {F(CID_YUY2),
  200.          F(CID_YUY2),
  201.          F(CID_YUY2),
  202.          F(CID_YUY2),
  203.          F(CID_YUY2)}
  204.     },
  205.     {
  206.         VER_PLATFORM_WIN32_WINDOWS,
  207.         {"Diamond Viper V330", "vprddle.DLL", 0x10080,0x4000a, 0x12d2, 0x18, 0, 0,
  208.         {0xd7b71c32,0x4358,0x11cf,{0x30,0x63,0x01,0x20,0xa5,0xc2,0xc9,0x35}}},
  209.         /* overlays (use YUY2 & UYVY only): */
  210.         {F(CID_YUY2) + F(CID_UYVY),
  211.         F(CID_YUY2) + F(CID_UYVY),
  212.         F(CID_YUY2) + F(CID_UYVY),
  213.         F(CID_YUY2) + F(CID_UYVY),
  214.         F(CID_YUY2) + F(CID_UYVY)},
  215.         /* blits (use YUY2, UYVY & matching RGBs): */
  216.         {F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB32),
  217.         F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB24),
  218.         F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB565),
  219.         F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB555),
  220.         F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB8)}
  221.     },
  222.     {
  223. VER_PLATFORM_WIN32_WINDOWS,
  224. {"NVIDIA GeForce 256 AGP Plus (Dell)",
  225.  "NVDD32.DLL",
  226.  0x10179,0x4000c,
  227.  0x10de, 0x100, 0x810de, 0x10, 
  228. {0xd7b71e3e,0x4240,0x11cf,{0x17,0x72,0x9,0x20,0xb3,0xc2,0xc9,0x35}}},
  229.         /* do NOT use overlays !!!: */
  230.         {0, 0, 0, 0, 0},
  231.         /* no blits either: */
  232.         {0, 0, 0, 0, 0}
  233.     },
  234.     {
  235.         VER_PLATFORM_WIN32_WINDOWS,
  236.         {"Diamond Viper V330", "vprdrvle.drv", 0x1007e, 0x4000a, 0x12d2, 0x18, 0x0, 0x0,
  237.         {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  238.         /* do NOT use overlays !!!: */
  239.         {0, 0, 0, 0, 0},
  240.         /* blits (use YUY2s & matching RGBs only): */
  241.         {F(CID_YUY2) + F(CID_RGB32),
  242.          F(CID_YUY2) + F(CID_RGB24),
  243.          F(CID_YUY2) + F(CID_RGB565),
  244.          F(CID_YUY2) + F(CID_RGB555),
  245.          F(CID_YUY2) + F(CID_RGB8)}
  246.     },
  247.     {
  248. VER_PLATFORM_WIN32_WINDOWS,
  249. {"Diamond Viper V550", "NVDD32.DLL", 0x10170,0x4000c, 0x10de, 0x20, 0x5501092, 0x4,
  250. {0xd7b71e3e,0x4360,0x11cf,{0x52,0x72,0x51,0x25,0xa7,0xc2,0xc9,0x35}}},
  251.         /* do NOT use overlays !!!: */
  252.         {0, 0, 0, 0, 0},
  253.         /* no blits either: */
  254.         {0, 0, 0, 0, 0}
  255.     },
  256.     {
  257. VER_PLATFORM_WIN32_WINDOWS,
  258.         {"[Hercules]  Thriller 3D Series (v 0.81.3539)",
  259.          "v200032.dll",
  260.          0xdd2,0x4000a,
  261.          0x1163, 0x2000, 0x34843, 0x6,
  262. {0xd7b71f83,0x6340,0x11cf,{0x21,0x26,0x3,0x20,0xa3,0xc2,0xc9,0x35}}},
  263.         /* do NOT use overlays !!!: */
  264.         {0, 0, 0, 0, 0},
  265.         /* no blits either: */
  266.         {0, 0, 0, 0, 0}
  267.     },
  268.     {
  269.         VER_PLATFORM_WIN32_NT,
  270.         {"Diamond Multimedia Systems, Inc.  Stealth II G460  Ver. 1.12x0dx0aV",
  271.         "stlthg46.dll", 0x0,0x40000,
  272.         /* Intel740: */  0x65746e49, 0x3034376c, 0, 0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  273.         /* do NOT use overlays !!!: */
  274.         {0, 0, 0, 0, 0},
  275.         /* no blits either: */
  276.         {0, 0, 0, 0, 0}
  277.     },
  278.     {
  279. VER_PLATFORM_WIN32_WINDOWS,
  280. {"STB Lightspeed 128, with STB Vision 95",
  281.  "stbvisn.drv", 0x514,0x40003,
  282.  0x100c, 0x3208, 0x0, 0x0, {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  283.         /* do NOT use overlays !!!: */
  284.         {0, 0, 0, 0, 0},
  285.         /* no blits either: */
  286.         {0, 0, 0, 0, 0}
  287.     },
  288.     {
  289.         VER_PLATFORM_WIN32_WINDOWS,
  290.         {"Diamond SpeedStar A50 for Windows 98", "DMSSA50x.dll", 0xc8,0x4000a,
  291.         0x1039, 0x6326, 0xa501092, 0xb,
  292.         {0xd7b71ed9,0x2066,0x11cf,{0xea,0x73,0x50,0x2a,0xae,0xc2,0xc9,0x35}}},
  293.         /* do NOT use overlays in 16-bit mode !!!: */
  294.         {F(CID_YUY2),
  295.          F(CID_YUY2),
  296.          0,
  297.          0,
  298.          F(CID_YUY2)},
  299.         /* no blits: */
  300.         {0, 0, 0, 0, 0}
  301.     },
  302.     /* these STB cards use nVidia Riva 182zx: */
  303.     {
  304.         VER_PLATFORM_WIN32_WINDOWS,
  305.         {"STB Velocity 128 3D", "stbv128.drv",
  306.         0x10074,0x4000a, 0x12d2, 0x18, 0x0, 0x0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  307.         /* do NOT use overlays !!!: */
  308.         {0, 0, 0, 0, 0},
  309.         /* blits (use YUY2s & matching RGBs only): */
  310.         {F(CID_YUY2) + F(CID_RGB32),
  311.          F(CID_YUY2) + F(CID_RGB24),
  312.          F(CID_YUY2) + F(CID_RGB565),
  313.          F(CID_YUY2) + F(CID_RGB555),
  314.          F(CID_YUY2) + F(CID_RGB8)}
  315.     },
  316.     {
  317.         VER_PLATFORM_WIN32_WINDOWS,
  318.         {"STB Velocity 128 (TV Support)", "STBV128.DRV",
  319.         0x1006d,0x4000a, 0x12d2, 0x18, 0x0, 0x0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  320.         /* do NOT use overlays !!!: */
  321.         {0, 0, 0, 0, 0},
  322.         /* blits (use YUY2s & matching RGBs only): */
  323.         {F(CID_YUY2) + F(CID_RGB32),
  324.          F(CID_YUY2) + F(CID_RGB24),
  325.          F(CID_YUY2) + F(CID_RGB565),
  326.          F(CID_YUY2) + F(CID_RGB555),
  327.          F(CID_YUY2) + F(CID_RGB8)}
  328.     },
  329.     {
  330.         VER_PLATFORM_WIN32_WINDOWS,
  331.         {"STB Lightspeed 128, without STB Vision 95", "stbls128.drv",
  332.         0x514,0x40003, 0x100c, 0x3208, 0x0, 0x0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  333.         /* overlays (use UYVY only): */
  334.         {F(CID_UYVY),
  335.         F(CID_UYVY),
  336.         F(CID_UYVY),
  337.         F(CID_UYVY),
  338.         0 /* this driver has a bug in 8-bit mode!!! */},
  339.         /* blits are not available anyway: */
  340.         {0, 0, 0, 0, 0}
  341.     },
  342.     {
  343.         VER_PLATFORM_WIN32_WINDOWS,
  344.         {"S3 Inc. Trio64V+", "s3_2.drv", 0x1083c,0x4000a,
  345.         0x5333, 0x8811, 0x0, 0x0,
  346.         {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  347.         /* disable overlays: */
  348.         {0, 0, 0, 0, 0},
  349.         /* RGB blits only: */
  350.         {F(CID_RGB32),
  351.          F(CID_RGB24),
  352.          F(CID_RGB565),
  353.          F(CID_RGB555),
  354.          F(CID_RGB8)}
  355.     },
  356.     {
  357.         VER_PLATFORM_WIN32_WINDOWS,
  358.         {"Chips And Technologies, Accelerator (new)", "chipsnd.drv",
  359.         0x3b6,0x40013,0x102c, 0xe0, 0x0, 0x0, {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  360.         /* do NOT use overlays !!!: */
  361.         {0, 0, 0, 0, 0},
  362.         /* blits (use YUY2s & matching RGBs only): */
  363.         {F(CID_YUY2) + F(CID_RGB32),
  364.          F(CID_YUY2) + F(CID_RGB24),
  365.          F(CID_YUY2) + F(CID_RGB565),
  366.          F(CID_YUY2) + F(CID_RGB555),
  367.          F(CID_YUY2) + F(CID_RGB8)}
  368.     },
  369.     {
  370.         VER_PLATFORM_WIN32_WINDOWS,
  371.         {"Cirrus Logic 7548 PCI", "cirrusmm.drv", 0x7ee,0x40003,
  372.          0x1013, 0x38, 0x0, 0x0,
  373.          {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  374.         /* does not have overlays...: */
  375.         {0, 0, 0, 0, 0},
  376.         /* RGB blits only: */
  377.         {F(CID_RGB32),
  378.          F(CID_RGB24),
  379.          F(CID_RGB565),
  380.          F(CID_RGB555),
  381.          F(CID_RGB8)}
  382.     },
  383.     /* NeoMagic controllers (widely used in Dell laptops): */
  384.     {
  385.         VER_PLATFORM_WIN32_WINDOWS,
  386.         {"NeoMagic MagicGraph 128XD", "NmgcDD.dll", 0x10006,0x4000a,
  387.         0x10c8, 0x4, 0x751028, 0x0,
  388.         {0xd7b71e28,0x4344,0x11cf,{0x9e,0x73,0x74,0x20,0xa5,0xc2,0xc9,0x35}}},
  389.         /* overlays (use YUY2 only): */
  390.         {F(CID_YUY2),
  391.         F(CID_YUY2),
  392.         F(CID_YUY2),
  393.         F(CID_YUY2),
  394.         F(CID_YUY2)},
  395.         /* don't use BLITS!!!: */
  396.         {0, 0, 0, 0, 0}
  397.     },
  398.     {
  399.         VER_PLATFORM_WIN32_WINDOWS,
  400.         {"NeoMagic MagicGraph 128XD", "Nmgc.drv",
  401.         0x10004,0x4000a, 0x10c8, 0x4, 0x0, 0x0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  402.         /* overlays (use YUY2 only): */
  403.         {F(CID_YUY2),
  404.         F(CID_YUY2),
  405.         F(CID_YUY2),
  406.         F(CID_YUY2),
  407.         F(CID_YUY2)},
  408.         /* don't use BLITS!!!: */
  409.         {0, 0, 0, 0, 0}
  410.     },
  411.     {
  412.         VER_PLATFORM_WIN32_WINDOWS,
  413.         {"NeoMagic MagicGraph 128 PCI", "nmx.drv",
  414.         0x5920000,0x40003, 0x0, 0x0, 0x0, 0x0, {0,0,0,{0,0,0,0,0,0,0,0}}},
  415.         /* overlays (use YUY2 only): */
  416.         {F(CID_YUY2),
  417.         F(CID_YUY2),
  418.         F(CID_YUY2),
  419.         F(CID_YUY2),
  420.         F(CID_YUY2)},
  421.         /* don't use BLITS!!!: */
  422.         {0, 0, 0, 0, 0}
  423.     },
  424.     {
  425.         VER_PLATFORM_WIN32_WINDOWS,
  426.         {"Diamond Stealth II G460",
  427.          "s2g432le.dll",
  428.          0x10542,0x4000a,
  429.          0x8086, 0x7800, 0x0, 0x0,
  430.          {0x0,0x0,0x0,{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}}},
  431.         /* overlays (use YUY2 only): */
  432.         {F(CID_YUY2),
  433.         F(CID_YUY2),
  434.         F(CID_YUY2),
  435.         F(CID_YUY2),
  436.         F(CID_YUY2)},
  437.         /* blits (use matching RGBs only): */
  438.         {F(CID_RGB32),
  439.         F(CID_RGB24),
  440.         F(CID_RGB565),
  441.         F(CID_RGB555),
  442.         F(CID_RGB8)}
  443.     },
  444.     {
  445.         VER_PLATFORM_WIN32_WINDOWS,
  446.         {"Diamond Stealth II G460",
  447.          "s2g432le.dll",
  448.          0x10542,0x4000a,
  449.          0x8086, 0x7800, 0x1001092, 0x21,
  450.          {0xd7b78e66,0x3b40,0x11cf,{0x60,0x76,0x1,0x21,0x84,0xc2,0xc9,0x35}}},
  451.         /* don't use overlays: */
  452.         {0, 0, 0, 0, 0},
  453.         /* blits (use matching RGBs only): */
  454.         {F(CID_RGB32),
  455.         F(CID_RGB24),
  456.         F(CID_RGB565),
  457.         F(CID_RGB555),
  458.         F(CID_RGB8)}
  459.     },
  460.     {
  461. VER_PLATFORM_WIN32_WINDOWS,
  462. {"NeoMagic MagicMedia 256AV",
  463.  "NmgcDD5.dll",
  464.  0x11451,0x4000a,
  465.  0x10c8, 0x5, 0x8f1028, 0x20, 
  466. {0xd7b71e28,0x4345,0x11cf,{0xc9,0x67,0x8e,0x20,0x85,0xc2,0xc9,0x35}}},
  467.         /* do NOT use overlays !!!: */
  468.         {0, 0, 0, 0, 0},
  469.         /* no blits either: */
  470.         {0, 0, 0, 0, 0}
  471.     },
  472.     {
  473. VER_PLATFORM_WIN32_WINDOWS,
  474.         {"NVIDIA RIVA TNT2 Ultra",
  475.          "NVDD32.DLL",
  476.          0x10170,0x4000c,
  477.          0x10de, 0x29, 0x10211102, 0x11, 
  478. {0xd7b71e3e,0x4369,0x11cf,{0xc2,0x73,0x20,0x30,0xb2,0xc2,0xc9,0x35}}},
  479.         /* don't use overlays: */
  480.         {0, 0, 0, 0, 0},
  481.         /* no blits either: */
  482.         {0, 0, 0, 0, 0}
  483.     }}
  484. };
  486. static BOOL DDPDB_Opened = FALSE;
  487. static BOOL DDPDB_NewProfile = FALSE;
  488. static time_t DDPDB_FileTime;
  490. /*
  491.  * Initializes profile database:        
  492.  */
  493. BOOL DDPDB_Open(char *pszProfile)
  494. {
  495.     BOOL bRet = FALSE;
  497.     /* check arguments: */
  498.     if (pszProfile && *pszProfile) {
  500.         struct _stat st;
  502.         /* get profile info: */
  503.         if (!_stat(pszProfile, &st) &&
  504.             /* check if we need to reload it: */
  505.             (!DDPDB_Opened || st.st_mtime != DDPDB_FileTime)) {
  507.             FILE *fp;
  508.             size_t s;
  510.             /* save profile time: */
  511.             DDPDB_FileTime = st.st_mtime;
  513.             /* try to open profile: */
  514.             if ((fp = fopen(pszProfile, "rb")) != NULL) {
  516.                 /* try to read this file: */
  517.                 if ((s = fread((void*)&DDPDB, 1, sizeof DDPDB, fp)) > 0 &&
  518.                     !strncmp(DDPDB.szMagic, DDPDB_MAGIC, 5) &&
  519.                     DDPDB.dwVersion >= DDPDB_VERSION &&
  520.                     DDPDB.dwNumProfiles >= 1 &&
  521.                     DDPDB.dwNumProfiles < MAXPROFILES &&
  522.                     DDPDB.dwNumProfiles * sizeof(DDDEVICEPROFILE) + 16 == s) {
  524.                     /* success: */
  525.                     DDPDB_Opened ++;
  526.                     DDPDB_NewProfile = TRUE;
  527.                     bRet = TRUE;
  528.                 }
  530.                 /* close file: */
  531.                 fclose(fp);
  532.             }
  533.         }
  534.     }
  535.     return bRet;
  536. }
  538. /*
  539.  * Terminates the use of profile database:
  540.  */
  541. BOOL DDPDB_Close ()
  542. {
  543.     return DDPDB_Opened && !--DDPDB_Opened;
  544. }
  546. /*
  547.  * Checks if profile has been updated.
  548.  */
  549. BOOL DDPDB_IsNewProfile ()
  550. {
  551.     BOOL bResult = DDPDB_NewProfile;
  552.     DDPDB_NewProfile = FALSE;
  553.     return bResult;
  554. }
  557. /*********************
  558.  * Default device profiles:
  559.  */
  560. static DDDEVICEPROFILE ddWinNTDefaultProfile =
  561. {
  562.     VER_PLATFORM_WIN32_NT,
  563.     {"", "", 0,0, 0},
  564.     /* overlays (use YUVs only): */
  565.     {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  566.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  567.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  568.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  569.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY)},
  570.     /* blits (use YUVs & matching RGBs): */
  571.     {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB32),
  572.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB24),
  573.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB565),
  574.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB555),
  575.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB8)}
  576. };
  578. static DDDEVICEPROFILE ddWin9xDefaultProfile =
  579. {
  580.     VER_PLATFORM_WIN32_WINDOWS,
  581.     {"", "", 0,0, 0,0,0,0, 0},
  582.     /* overlays (use YUVs only): */
  583.     {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  584.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  585.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  586.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY),
  587.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY)},
  588.     /* blits (use YUVs & matching RGBs): */
  589.     {F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB32),
  590.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB24),
  591.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB565),
  592.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB555),
  593.      F(CID_YV12) + F(CID_YUY2) + F(CID_UYVY) + F(CID_RGB8)}
  594. };
  596. /*
  597.  * Get pointer to a best matching DirectDraw device profile.
  598.  */
  599. LPDDDEVICEPROFILE DDPDB_GetDeviceProfile (LPDIRECTDRAW lpDD)
  600. {
  601.     OSVERSIONINFO osVersion;
  602.     DDDEVICEIDENTIFIER ddID;                    /* DirectDraw & Win95 info */
  603.     char szChipType[MAXCHIPTYPE];               /* NT info      */
  604.     unsigned int bestMatchIdx, deviceBestMatch, driverBestMatch;
  605.     unsigned int i, deviceMatch, driverMatch;
  607. #if DIRECTDRAW_VERSION > 0x0500
  608.     LPDIRECTDRAW4 lpDD4;
  609. #endif
  611.     /* check if we are runnning NT: */
  612.     memset(&osVersion,0, sizeof(OSVERSIONINFO));
  613.     osVersion.dwOSVersionInfoSize  = sizeof(OSVERSIONINFO);
  614.     if (GetVersionEx(&osVersion) && osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT) {
  616.         /* try to get WinNT device information: */
  617.         if (GetWinNTDeviceID (&ddID, szChipType)) {
  619.             /* clear best match criteria: */
  620.             deviceBestMatch = driverBestMatch = bestMatchIdx = 0;
  622.             /* scan database: */
  623.             for (i = 0; i < DDPDB.dwNumProfiles; i++) {
  625.                 /* check platform ID: */
  626.                 if (DDPDB.ddProfiles[i].dwPlatformId == VER_PLATFORM_WIN32_NT) {
  628.                     /* clear match criteria: */
  629.                     deviceMatch = driverMatch = 0;
  631.                     /* check non-critical parameters: */
  632.                     if (!DDPDB.ddProfiles[i].ID.WinNT.szDescription[0] ||
  633.                         !strncmp (DDPDB.ddProfiles[i].ID.WinNT.szDescription, ddID.szDescription, MAXDESCRIPT-1))
  634.                         deviceMatch ++;
  635.                     if (!DDPDB.ddProfiles[i].ID.WinNT.szDriver[0] ||
  636.                         !strnicmp (DDPDB.ddProfiles[i].ID.WinNT.szDriver, ddID.szDriver, MAXDRIVER-1))
  637.                         driverMatch ++;
  639.                     /* check critical data: */
  640.                     if (!DDPDB.ddProfiles[i].ID.WinNT.dwDriverVersionHighPart)
  641.                         driverMatch ++;
  642.                     else if (DDPDB.ddProfiles[i].ID.WinNT.dwDriverVersionHighPart == (DWORD)ddID.liDriverVersion.HighPart)
  643.                         driverMatch += 2;
  644.                     else
  645.                         continue;
  646.                     if (!DDPDB.ddProfiles[i].ID.WinNT.dwDriverVersionLowPart)
  647.                         driverMatch ++;
  648.                     else if (DDPDB.ddProfiles[i].ID.WinNT.dwDriverVersionLowPart == (DWORD)ddID.liDriverVersion.LowPart)
  649.                         driverMatch += 2;
  650.                     else
  651.                         continue;
  652.                     if (!DDPDB.ddProfiles[i].ID.WinNT.szChipType[0])
  653.                         deviceMatch += 1;
  654.                     else if (!strncmp (DDPDB.ddProfiles[i].ID.WinNT.szChipType, szChipType, MAXCHIPTYPE-1))
  655.                         deviceMatch += 2;
  656.                     else
  657.                         continue;
  659.                     /* check the results: */
  660.                     if (deviceMatch + driverMatch > deviceBestMatch + driverBestMatch &&
  661.                         deviceMatch >= deviceBestMatch && driverMatch >= driverBestMatch)
  662.                     {
  663.                         /* update best match: */
  664.                         deviceBestMatch = deviceMatch;
  665.                         driverBestMatch = driverMatch;
  666.                         bestMatchIdx = i;
  667.                     }
  668.                 }
  669.             }
  671.             /* check overal search results: */
  672.             if (deviceBestMatch && driverBestMatch >= 3)
  673.             {
  674.                 return DDPDB.ddProfiles + bestMatchIdx ;
  675.             }
  676.             
  677.         }
  679.         /* return WinNT default profile: */
  680.         return &ddWinNTDefaultProfile;
  682.     } else { /* Win9x: */
  684.         /* try to get DirectDraw device identifier: */
  685.         memset (&ddID, 0, sizeof (DDDEVICEIDENTIFIER));
  686.         
  687. #if DIRECTDRAW_VERSION > 0x0500 && !defined(IMPORT)
  688.         if ((IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void**)&lpDD4) == DD_OK &&
  689.             IDirectDraw4_GetDeviceIdentifier(lpDD4, &ddID, DDGDI_GETHOSTIDENTIFIER) == DD_OK) ||
  690.             /* try to gather Win9x device information manually: */
  691.             GetWin9xDeviceID (&ddID)) {
  693.             /* clear best match criteria: */
  694.             deviceBestMatch = driverBestMatch = bestMatchIdx = 0;
  696.             /* scan database: */
  697.             for (i = 0; i < DDPDB.dwNumProfiles; i++) {
  699.                 /* check platform ID: */
  700.                 if (DDPDB.ddProfiles[i].dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
  702.                     /* clear match criteria: */
  703.                     deviceMatch = driverMatch = 0;
  705.                     /* check non-critical parameters: */
  706.                     if (!DDPDB.ddProfiles[i].ID.Win9x.szDescription[0] ||
  707.                         !strncmp (DDPDB.ddProfiles[i].ID.Win9x.szDescription, ddID.szDescription, MAXDESCRIPT-1))
  708.                         deviceMatch ++;
  709.                     if (!DDPDB.ddProfiles[i].ID.Win9x.szDriver[0] ||
  710.                         !strnicmp (DDPDB.ddProfiles[i].ID.Win9x.szDriver, ddID.szDriver, MAXDRIVER-1))
  711.                         driverMatch ++;
  713.                     /* check critical data: */
  714.                     if (!DDPDB.ddProfiles[i].ID.Win9x.dwDriverVersionHighPart)
  715.                         driverMatch ++;
  716.                     else if (DDPDB.ddProfiles[i].ID.Win9x.dwDriverVersionHighPart == (DWORD)ddID.liDriverVersion.HighPart)
  717.                         driverMatch += 2;
  718.                     else
  719.                         continue;
  720.                     if (!DDPDB.ddProfiles[i].ID.Win9x.dwDriverVersionLowPart)
  721.                         driverMatch ++;
  722.                     else if (DDPDB.ddProfiles[i].ID.Win9x.dwDriverVersionLowPart == (DWORD)ddID.liDriverVersion.LowPart)
  723.                         driverMatch += 2;
  724.                     else
  725.                         continue;
  726.                     if (!DDPDB.ddProfiles[i].ID.Win9x.dwVendorId)
  727.                         deviceMatch ++;
  728.                     else if (DDPDB.ddProfiles[i].ID.Win9x.dwVendorId == ddID.dwVendorId)
  729.                         deviceMatch += 2;
  730.                     else
  731.                         continue;
  732.                     if (!DDPDB.ddProfiles[i].ID.Win9x.dwDeviceId)
  733.                         deviceMatch ++;
  734.                     else if (DDPDB.ddProfiles[i].ID.Win9x.dwDeviceId == ddID.dwDeviceId)
  735.                         deviceMatch += 2;
  736.                     else
  737.                         continue;
  739.                     /* check the results: */
  740.                     if (deviceMatch + driverMatch > deviceBestMatch + driverBestMatch &&
  741.                         deviceMatch >= deviceBestMatch && driverMatch >= driverBestMatch) {
  743.                         /* update best match: */
  744.                         deviceBestMatch = deviceMatch;
  745.                         driverBestMatch = driverMatch;
  746.                         bestMatchIdx  = i;
  747.                     }
  748.                 }
  749.             }
  751.             /* check overal search results: */
  752.             if (deviceBestMatch >= 3 && driverBestMatch >= 3)
  753.                 return DDPDB.ddProfiles + bestMatchIdx;
  754.         }
  755. #endif //DIRECTDRAW_VERSION <= 0x0500
  757.         /* return default profile: */
  758.         return &ddWin9xDefaultProfile;
  759.     }
  760. }
  762. /* packs 2-character string into a normal, single-character one: */
  763. static void PackWideString (char *dest, char *src, int n)
  764. {
  765.     register char *d = dest, *s = src;
  766.     while (n-- && *s) {
  767.         *d = *s;
  768.         s += 2;
  769.         d += 1;
  770.     }
  771.     *d = '';
  772. }
  774. static BOOL GetFileVersion(LPTSTR pPath, LPDDDEVICEIDENTIFIER lpddID)
  775. {
  776.     DWORD   dwVerInfoSize;
  777.     DWORD   dwVerHnd;
  778.     BOOL    fSuccess = FALSE;
  780.     // load version.dll
  781.     HINSTANCE     hLib = NULL;
  782.     VERQUERYVALUE     _pVerQueryValue = NULL;
  783.     GETFILEVERSIONINFO     _pGetFileVersionInfo = NULL;
  784.     GETFILEVERSIONINFOSIZE  _pGetFileVersionInfoSize = NULL;
  786.     hLib = LoadLibrary("version.dll");
  788.     if (hLib)
  789.     {
  790. _pVerQueryValue = (VERQUERYVALUE)GetProcAddress(hLib, "VerQueryValueA");
  791. _pGetFileVersionInfo = (GETFILEVERSIONINFO)GetProcAddress(hLib, "GetFileVersionInfoA");
  792. _pGetFileVersionInfoSize = (GETFILEVERSIONINFOSIZE)GetProcAddress(hLib, "GetFileVersionInfoSizeA");
  793.     }
  795.     if (_pVerQueryValue &&
  796. _pGetFileVersionInfo &&
  797. _pGetFileVersionInfoSize)
  798.     {
  799. /* set everything to 0: */
  800. lpddID->liDriverVersion.HighPart = 0;
  801. lpddID->liDriverVersion.LowPart = 0;
  803. /* get size of version info: */
  804. if ((dwVerInfoSize = _pGetFileVersionInfoSize(pPath, &dwVerHnd)) != 0) {
  806.     HANDLE  hMem;                     /* handle to mem alloc'ed */
  807.     LPSTR   lpstrVffInfo;             /* Pointer to block to hold info */
  809.     /* Get a block big enough to hold version info */
  810.     hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
  811.     lpstrVffInfo  = (char *)GlobalLock(hMem);
  813.     /* get file version info: */
  814.     if (_pGetFileVersionInfo(pPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo)) {
  816. UINT    VersionLen;
  817. LPSTR   lpVersion;
  819. /* query version info: */
  820. if (_pVerQueryValue(lpstrVffInfo, "\",
  821.     (void FAR* FAR*)&lpVersion, &VersionLen)) {
  823.     /* copy version info: */
  824.     VS_FIXEDFILEINFO* pFileInfo = (VS_FIXEDFILEINFO*)lpVersion;
  825.     lpddID->liDriverVersion.HighPart = pFileInfo->dwFileVersionMS;
  826.     lpddID->liDriverVersion.LowPart = pFileInfo->dwFileVersionLS;
  828.     /* indicate success: */
  829.     fSuccess = TRUE;
  830. }
  831.     }
  833.     /* Let go of the memory */
  834.     GlobalUnlock(hMem);
  835.     GlobalFree(hMem);
  836. }
  837.     }
  839.     FreeLibrary(hLib);
  841.     return fSuccess;
  842. }
  844. #define MAX_BUF        512
  845. #ifdef TRACE
  846. #define Trace(pMsg)  printf("-->%sn", pMsg)
  847. #else
  848. #define Trace(pMsg)  ((void)0)
  849. #endif
  851. /*
  852.  * This whole thing is based on Jeff's CFullScreenInfo:: code:
  853.  */
  854. BOOL GetWinNTDeviceID (LPDDDEVICEIDENTIFIER lpddID, char *pszChipType)
  855. {
  856.     HKEY        hKey;
  857.     char        szBuffer[MAX_BUF];
  858.     DWORD       bufSize  = sizeof(szBuffer) - 1;
  859.     char        pDLLPath[_MAX_PATH];
  860.     const char* pszStrip = "\registry\machine\";
  861.     LONG        res = ERROR_SUCCESS;
  862.     BOOL        retVal = FALSE;
  863.     
  864.     /* open Hardware\DEVICEMAP\VIDEO key: */
  865.     res = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  866.                         "Hardware\DEVICEMAP\VIDEO",
  867.                         0,
  868.                         KEY_READ,
  869.                         &hKey
  870.                         );
  871.     
  872.     if( ERROR_SUCCESS == res )
  873.     {
  874.         /* query a Video0 entry: */
  875.         memset(szBuffer, 0, sizeof(szBuffer) );
  876.         res = RegQueryValueEx(hKey,
  877.                               "\Device\Video0",
  878.                               NULL,
  879.                               NULL,
  880.                               (LPBYTE) szBuffer,
  881.                               (LPDWORD)&bufSize);
  883.         //Done with first key.
  884.         RegCloseKey(hKey);
  885.         
  886.         if( ERROR_SUCCESS == res )
  887.         {
  888.             //Find RegistryMachine in the key's values and strip it
  889.             //off. Some machines write the key in different cases.
  890.             //If we can't find it, something is wrong. It also must
  891.             //be at the start of the string.
  892.             _strlwr( szBuffer );
  893.             if( strstr(szBuffer, pszStrip) == szBuffer )
  894.             {
  895.                 res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  896.                                    szBuffer + strlen(pszStrip), //Skip pre-log.
  897.                                    0,
  898.                                    KEY_READ,
  899.                                    &hKey);
  901.                 if( res == ERROR_SUCCESS )
  902.                 {
  903.                     /* get Device Description: */
  904.                     memset( szBuffer, 0, sizeof(szBuffer) );
  905.                     bufSize = sizeof( szBuffer)-1;
  906.                     res = RegQueryValueEx( hKey,
  907.                                            "HardwareInformation.AdapterString",
  908.                                            NULL,
  909.                                            NULL,
  910.                                            (LPBYTE) szBuffer,
  911.                                            (LPDWORD)&bufSize);
  912.             
  913.                     if( ERROR_SUCCESS == res )
  914.                     {
  915.                         /* move it to dddid: */
  916.                         PackWideString(lpddID->szDescription, szBuffer, MAXDESCRIPT-1);
  918.                         /* get ChipType information: */
  919.                         memset( szBuffer, 0, sizeof(szBuffer) );
  920.                         bufSize = sizeof( szBuffer)-1;
  921.                         res = RegQueryValueEx( hKey,
  922.                                                "HardwareInformation.ChipType",
  923.                                                NULL,
  924.                                                NULL,
  925.                                                (LPBYTE) szBuffer,
  926.                                                (LPDWORD)&bufSize);
  927.             
  928.                         if( ERROR_SUCCESS == res )
  929.                         {
  930.                             /* copy it: */
  931.                             PackWideString (pszChipType, szBuffer, MAXCHIPTYPE-1);
  933.                             /* get driver name: */
  934.                             memset( szBuffer, 0, sizeof(szBuffer) );
  935.                             bufSize = sizeof( szBuffer)-1;
  936.                             res = RegQueryValueEx( hKey,
  937.                                                    "InstalledDisplayDrivers",
  938.                                                    NULL,
  939.                                                    NULL,
  940.                                                    (LPBYTE) szBuffer,
  941.                                                    (LPDWORD)&bufSize);
  942.                             if( ERROR_SUCCESS == res && bufSize )
  943.                             {
  944.                                 //copy driver name
  945.                                 strcat(szBuffer, ".dll");
  946.                                 strncpy(lpddID->szDriver, szBuffer, MAXDRIVER-1);
  948.                                 // get full path to the driver:
  949.                                 if(GetSystemDirectory(pDLLPath, _MAX_PATH) != 0)
  950.                                 {
  951.                                     strcat(pDLLPath, "\");
  952.                                     strcat(pDLLPath, szBuffer);
  954.                                     // query file version:
  955.                                     if( GetFileVersion(pDLLPath, lpddID) )
  956.                                     {
  957.                                         retVal = TRUE;
  958.                                     }
  959.                                     
  960.                                 }
  961.                             }
  962.                         }
  963.                     }
  964.                     RegCloseKey(hKey);
  965.                 }
  966.             }
  967.         }
  968.     }
  969.     
  970.     return retVal;
  971. }
  973. static BOOL DevNodeIsActive(char *szDeviceID)
  974. {
  975.     HINSTANCE hDevNodeInst;
  976.     DWORD dwStatus;
  977.     DWORD dwProblemNumber;
  978.     DWORD cr;
  980.     DWORD (WINAPI *pGetDevNodeStatus32Call) (const char *, LPDWORD, LPDWORD);
  982.     /*
  983.      * 10 is a magic number for the configuration manager api
  984.      * that eventually gets called in the 16 bit dll.
  985.      */
  986.     dwStatus = dwProblemNumber = cr = 10;
  987.     pGetDevNodeStatus32Call = 0;
  989.     if ((hDevNodeInst = LoadLibrary(_32BIT_DLLNAME)) != 0)
  990.     {
  991.         if (((FARPROC)pGetDevNodeStatus32Call = GetProcAddress(hDevNodeInst, "GetDevNodeStatus32Call")) != NULL)
  992.         {
  993.             cr = (* pGetDevNodeStatus32Call) (szDeviceID, &dwStatus, &dwProblemNumber);
  994.         }
  996.         FreeLibrary(hDevNodeInst);
  997.     }
  999.     return cr == 0 && dwProblemNumber == 0;
  1000. }
  1002. static unsigned int hex2uint (char *p, int n)
  1003. {
  1004.     register unsigned int i = 0;
  1005.     while (n--)
  1006.     {
  1007.         register unsigned int j = *p;
  1008.         i <<= 4;
  1009.         if (j <= '9')   j -= '0';
  1010.         else            j -= 'A' - 10;
  1011.         p ++;
  1012.         i |= j;
  1013.     }
  1014.     return i;
  1015. }
  1017. /*
  1018.  * Extract Win9x DirectDraw device information:
  1019.  */
  1020. BOOL GetWin9xDeviceID (LPDDDEVICEIDENTIFIER lpddID)
  1021. {
  1022.     static char *szEnum_Name [ENUM_MAX] = {
  1023.         REGSTR_KEY_ROOTENUM, REGSTR_KEY_BIOSENUM,
  1024.         REGSTR_KEY_PCIENUM,  REGSTR_KEY_ISAENUM,
  1025.         REGSTR_KEY_EISAENUM, REGSTR_KEY_PCMCIAENUM
  1026.     };
  1028.     /* moved out of stack for safety reasons... */
  1029.     static char szCurrentKey [MAX_BUF];
  1030.     static char szCurrentDeviceNode[MAX_BUF];
  1031.     static char szCurrentDevice [MAX_BUF];
  1032.     static char szClass [64];
  1033.     static char szDeviceID [MAX_BUF];
  1034.     static char szSoftwareKey [MAX_BUF];
  1035.     static char pDLLPath [_MAX_PATH];
  1037.     ULONG ulType;
  1038.     ULONG32 cbData;
  1039.     HKEY hSoftwareKey;
  1040.     char *p;
  1041.     int i;
  1043.     Trace("entering GetWin9xDeviceID... ");
  1045.     /* we want to look through the ENUMBIOS, ENUMISAPNP, and ENUMPCI
  1046.      * trees for devices of the DISPLAY class.  For each display device
  1047.      * we find we will ask the Device manager if it is active. */
  1048.     for (i = 0; i < ENUM_MAX; i++)
  1049.     {
  1050.         HKEY hBusKey;
  1051.         /* construct a string for the current key: */
  1052.         strcpy(szCurrentKey, REGSTR_KEY_ENUM);
  1053.         strcat(szCurrentKey, "\");
  1054.         strcat(szCurrentKey, szEnum_Name[i]);
  1056.         Trace("nopenining LOCAL_MACHINE key:");
  1057.         Trace(szCurrentKey);
  1059.         /* start reading the devices */
  1060.         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCurrentKey, 0, KEY_READ, &hBusKey) == ERROR_SUCCESS)
  1061.         {
  1062.             ULONG32 dwDevNodeEnumIndex = 0;
  1064.             Trace("opened;");
  1066.             /* Enumerate all of the devices on the bus */
  1067.             while (1)
  1068.             {
  1069.                 HKEY hDeviceNodeKey;
  1071.                 memset(szCurrentDeviceNode, 0, sizeof(szCurrentDeviceNode));
  1072.                 cbData = sizeof(szCurrentDeviceNode) - 1;
  1073.                 if (RegEnumKeyEx(hBusKey, dwDevNodeEnumIndex, szCurrentDeviceNode, &cbData, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
  1074.                     break;
  1076.                 /* construct a string for current device node: */
  1077.                 strcpy(szCurrentKey,REGSTR_KEY_ENUM);
  1078.                 strcat(szCurrentKey, "\");
  1079.                 strcat(szCurrentKey, szEnum_Name[i]);
  1080.                 strcat(szCurrentKey, "\");
  1081.                 strcat(szCurrentKey, szCurrentDeviceNode);
  1083.                 Trace("opening device node:");
  1084.                 Trace(szCurrentKey);
  1086.                 /* get the registry key for the current device node */
  1087.                 if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCurrentKey, 0, KEY_READ, &hDeviceNodeKey) == ERROR_SUCCESS)
  1088.                 {
  1089.                     ULONG32 dwHWDeviceEnumIndex = 0;
  1091.                     Trace("opened;");
  1093.                     /* enumerate all of the hardware devices in this Device Node */
  1094.                     while (1)
  1095.                     {
  1096.                         HKEY hHWDeviceKey;
  1097.                         int nBaseKeyLength;
  1099.                         memset(szCurrentDevice, 0, sizeof(szCurrentDevice));
  1100.                         cbData = sizeof(szCurrentDevice) - 1;
  1101.                         if (RegEnumKeyEx(hDeviceNodeKey, dwHWDeviceEnumIndex, szCurrentDevice, &cbData, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
  1102.                             break;
  1104.                         /* get the registry key for the current hardware device */
  1105.                         nBaseKeyLength = strlen(szCurrentKey);
  1107.                         /* append currect device name: */
  1108.                         strcat(szCurrentKey, "\");
  1109.                         strcat(szCurrentKey, szCurrentDevice);
  1111.                         Trace("opening device named:");
  1112.                         Trace(szCurrentKey);
  1114.                         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCurrentKey, 0, KEY_READ, &hHWDeviceKey) == ERROR_SUCCESS)
  1115.                         {
  1116.                             Trace("opened;");
  1118.                             /* ask if this device is a "DISPLAY" device by checking it's class */
  1119.                             cbData = sizeof(szClass);
  1120.                             szClass[0] = 0;
  1122.                             Trace("quering class of this device: ");
  1124.                             if (RegQueryValueEx(hHWDeviceKey, "Class", 0, &ulType, (LPBYTE) szClass, &cbData) == ERROR_SUCCESS)
  1125.                             {
  1126.                                 Trace("obtained:");
  1127.                                 Trace(szClass);
  1129.                                 /* is it Display??? */
  1130.                                 if (!stricmp(szClass, "DISPLAY"))
  1131.                                 {
  1132.                                     Trace("looks like a display adapter!!");
  1134.                                     /* if it is a display device then we want to find out if it is
  1135.                                      * the active device for this class. */
  1136.                                     memset(szSoftwareKey, 0, sizeof(szSoftwareKey));
  1137.                                     cbData = sizeof(szSoftwareKey) - 1;
  1139.                                     /* create a string for Device ID: */
  1140.                                     strcpy(szDeviceID, szEnum_Name[i]);
  1141.                                     strcat(szDeviceID, "\");
  1142.                                     strcat(szDeviceID, szCurrentDeviceNode);
  1143.                                     strcat(szDeviceID, "\");
  1144.                                     strcat(szDeviceID, szCurrentDevice);
  1146.                                     Trace("quering device ID:");
  1147.                                     Trace(szDeviceID);
  1149.                                     /* get the registry key name for the software key for the device,
  1150.                                      * if it is not null and this is the active device then we are done. */
  1151.                                     if (RegQueryValueEx(hHWDeviceKey, "Driver", 0, &ulType, (LPBYTE) szSoftwareKey, &cbData) == ERROR_SUCCESS &&
  1152.                                         szSoftwareKey[0] != '0' &&
  1153.                                         DevNodeIsActive(szDeviceID))    /* Call Config Manager in 16-bit code */
  1154.                                     {
  1155.                                         Trace("device found!!!:");
  1157.                                         /* close all open keys and continue processing... */
  1158.                                         RegCloseKey(hHWDeviceKey);
  1159.                                         RegCloseKey(hDeviceNodeKey);
  1160.                                         RegCloseKey(hBusKey);
  1161.                                         goto cont;
  1162.                                     }
  1163.                                 }
  1164.                             }
  1165.                             /* close hardware device key: */
  1166.                             RegCloseKey(hHWDeviceKey);
  1167.                         }
  1168.                         /* reset the key to the base for the next time through the loop: */
  1169.                         memset (szCurrentKey + nBaseKeyLength, 0, sizeof(szCurrentKey) - nBaseKeyLength);
  1171.                         /* move to next device key */
  1172.                         dwHWDeviceEnumIndex ++;
  1173.                     }
  1174.                     /* close device node key: */
  1175.                     RegCloseKey(hDeviceNodeKey);
  1176.                 }
  1177.                 /* move to the next device node */
  1178.                 dwDevNodeEnumIndex ++;
  1179.             }
  1180.             /* close bus key: */
  1181.             RegCloseKey(hBusKey);
  1182.         }
  1183.     }
  1184.     Trace("exiting GetWin9xDeviceID (device not found):");
  1185.     /* not found: */
  1186.     return FALSE;
  1189. cont:
  1190.     /* get Vendor ID: */
  1191.     if ((p = strstr(szDeviceID, "VEN_")) != 0)
  1192.         lpddID->dwVendorId = hex2uint (p + strlen("VEN_"), 4);
  1194.     /* get DeviceID: */
  1195.     if ((p = strstr(szDeviceID, "DEV_")) != 0)
  1196.         lpddID->dwDeviceId = hex2uint (p + strlen("DEV_"), 4);
  1198.     /* get Revision #: */
  1199.     if ((p = strstr(szDeviceID, "REV_")) != 0)
  1200.         lpddID->dwRevision = hex2uint (p + strlen("REV_"), 4);
  1202.     /* if we found the software key, we want to go get the Driver description
  1203.      * and the driver file name: */
  1205.     /* create a software key string: */
  1206.     strcpy(szCurrentKey, REGSTR_PATH_CLASS);
  1207.     strcat(szCurrentKey, "\");
  1208.     strcat(szCurrentKey, szSoftwareKey);
  1210.     Trace("opening software key:");
  1211.     Trace(szCurrentKey);
  1213.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCurrentKey, 0, KEY_READ, &hSoftwareKey) == ERROR_SUCCESS)
  1214.     {
  1215.         /* use external buffer: */
  1216.         char* szAdapterString = lpddID->szDescription;
  1217.         cbData = MAX_DDDEVICEID_STRING;
  1219.         Trace("opened;");
  1221.         /* query device description: */
  1222.         RegQueryValueEx(hSoftwareKey, "DriverDesc", 0, &ulType, (LPBYTE)szAdapterString, &cbData);
  1224.         /* close software key; */
  1225.         RegCloseKey(hSoftwareKey);
  1226.     }
  1228.     /* now look in the Default key for the driver file name */
  1229.     strcat(szCurrentKey, "\DEFAULT");
  1230.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCurrentKey, 0, KEY_READ, &hSoftwareKey) == ERROR_SUCCESS)
  1231.     {
  1232.         char* szDisplayDriverName = lpddID->szDriver;
  1233.         cbData = MAX_DDDEVICEID_STRING;
  1235.         /* query driver name: */
  1236.         RegQueryValueEx(hSoftwareKey, "drv", 0, &ulType, (LPBYTE)szDisplayDriverName, &cbData);
  1238.         /* close software key: */
  1239.         RegCloseKey(hSoftwareKey);
  1241.         /* get the file version: */
  1242.         if (GetSystemDirectory(pDLLPath, _MAX_PATH) != 0)
  1243.         {
  1244.             strcat(pDLLPath, "\");
  1245.             strcat(pDLLPath, szDisplayDriverName);
  1247.             Trace("trying to get a file version:");
  1249.             /* query file version: */
  1250.             GetFileVersion(pDLLPath, lpddID);
  1251.         }
  1252.     }
  1254.     Trace("exiting GetWin9xDeviceID:");
  1255.     return TRUE;
  1256. }
  1259. /***********************************
  1260.  * Utilities:
  1261.  **************************************/
  1263. #ifdef DUMP
  1264. /* a simple database creation program: */
  1265. int main (int argc, char *argv[])
  1266. {
  1267.     FILE *fp;
  1268.     int s;
  1270.     /* check arguments: */
  1271.     if (argc < 2) {
  1272.         fprintf (stderr, "Use:ntDDPDB <file name>n");
  1273.         exit (EXIT_FAILURE);
  1274.     }
  1276.     /* create a file: */
  1277.     if ((fp = fopen (argv[1], "wb+")) == NULL) {
  1278.         fprintf (stderr, "Cannot open database file.n");
  1279.         exit (EXIT_FAILURE);
  1280.     }
  1282.     /* calculate the size of file: */
  1283.     s = 16 + DDPDB.dwNumProfiles * sizeof(DDDEVICEPROFILE);
  1285.     /* dump raw data: */
  1286.     if (fwrite((void*)&DDPDB, 1, s, fp) != s) {
  1287.         fprintf (stderr, "Write error (out of disk space?).n");
  1288.         exit (EXIT_FAILURE);
  1289.     }
  1291.     /* close file: */
  1292.     fclose(fp);
  1293.     exit (EXIT_SUCCESS);
  1294. }
  1295. #endif /* DUMP */
  1298. #ifdef IMPORT
  1299. /* a profile generation program: */
  1300. int main ()
  1301. {
  1302.     OSVERSIONINFO osVersion;
  1303.     LPDIRECTDRAW lpDD;
  1304.     LPDIRECTDRAW4 lpDD4;
  1305.     DDDEVICEIDENTIFIER ddID;                    /* DirectDraw & Win95 info      */
  1306.     char szChipType[MAXCHIPTYPE];               /* NT info      */
  1308.     /* try to load DirectDraw library: */
  1309.     if (DirectDrawCreate (NULL, &lpDD, NULL) != DD_OK) {
  1310.         printf ("Cannot create DirectDraw object!");
  1311.         exit(EXIT_FAILURE);
  1312.     }
  1314.     /* check if we are runnning NT: */
  1315.     memset(&osVersion,0, sizeof(OSVERSIONINFO));
  1316.     osVersion.dwOSVersionInfoSize  = sizeof(OSVERSIONINFO);
  1317.     if (GetVersionEx(&osVersion) && osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT)
  1318.     {
  1319.         /* try to get WinNT device information: */
  1320.         if (!GetWinNTDeviceID (&ddID, szChipType)) {
  1321.             fprintf (stderr, "Cannot get NT driver infon");
  1322.             exit (EXIT_FAILURE);
  1323.         }
  1324.         /* print header: */
  1325.         printf ("tVER_PLATFORM_WIN32_NT,n");
  1327.     }
  1328.     else
  1329.     { /* Win9x: */
  1330. #ifndef IMPORT        
  1331.         /* try to get DirectDraw device identifier: */
  1332.         memset (&ddID, 0, sizeof (DDDEVICEIDENTIFIER));
  1333.         if (
  1334.             (IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw4, (void**)&lpDD4) != DD_OK ||
  1335.             IDirectDraw4_GetDeviceIdentifier(lpDD4, &ddID, DDGDI_GETHOSTIDENTIFIER) != DD_OK) &&
  1336.             /* try to gather Win9x device information manually: */
  1337.             !GetWin9xDeviceID (&ddID)) {
  1338.                 fprintf (stderr, "Cannot get Win9x driver infon");
  1339.                 exit (EXIT_FAILURE);
  1340.             }
  1342.         /* print header: */
  1343.         printf( "tVER_PLATFORM_WIN32_WINDOWS,n");
  1344. #else
  1345.         printf( "Need more work to run this tool on win95 machines.....n" );
  1346. #endif        
  1347.     }
  1349.     /* dump description: */
  1350.     ddID.szDescription[MAXDESCRIPT-1] = '';
  1351.     printf ("t{"%s",n", ddID.szDescription);
  1353.     /* dump driver: */
  1354.     ddID.szDriver[MAXDRIVER-1] = '';
  1355.     printf ("t "%s",n", ddID.szDriver);
  1357.     /* driver version: */
  1358.     printf ("t 0x%x,0x%x,n", ddID.liDriverVersion.LowPart, ddID.liDriverVersion.HighPart);
  1360.     if (osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT) {
  1361.         /* dump: WinNT vars:*/
  1362.         printf ("t 0x%x, 0x%x, 0x%x, 0x%x, n",
  1363.             *(DWORD*)(szChipType), *(DWORD*)(szChipType+4), *(DWORD*)(szChipType+8), *(DWORD*)(szChipType+12));
  1365.         printf ("t {0x%x,0x%x,0x%x,{0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x}}n",
  1366.             *(DWORD*)(szChipType+16), *(WORD*)(szChipType+20), *(WORD*)(szChipType+22),
  1367.             szChipType[24], szChipType[25], szChipType[26], szChipType[27],
  1368.             szChipType[28], szChipType[29], szChipType[30], szChipType[31]);
  1370.     } else {
  1371.         /* dump: Win9x vars:*/
  1372.         printf ("t 0x%x, 0x%x, 0x%x, 0x%x, n",
  1373.             ddID.dwVendorId, ddID.dwDeviceId, ddID.dwSubSysId, ddID.dwRevision);
  1374.         printf ("t {0x%x,0x%x,0x%x,{0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x}}n",
  1375.             ddID.guidDeviceIdentifier.Data1,
  1376.             ddID.guidDeviceIdentifier.Data2,    ddID.guidDeviceIdentifier.Data3,
  1377.             ddID.guidDeviceIdentifier.Data4[0], ddID.guidDeviceIdentifier.Data4[1],
  1378.             ddID.guidDeviceIdentifier.Data4[2], ddID.guidDeviceIdentifier.Data4[3],
  1379.             ddID.guidDeviceIdentifier.Data4[4], ddID.guidDeviceIdentifier.Data4[5],
  1380.             ddID.guidDeviceIdentifier.Data4[6], ddID.guidDeviceIdentifier.Data4[7]);
  1381.     }
  1383.     exit (EXIT_SUCCESS);
  1384. }
  1385. #endif /* IMPORT */
  1387. /* ddpdb.c -- end of file */