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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
ddpdb.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：50k
源码类别：

Symbian

开发平台：

Visual C++

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