gl/mesa/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Luca Barbieri
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 #include "dxgi_private.h"
  28 extern "C" {
  29 #include "native.h"
  30 #include "util/u_format.h"
  31 #include "util/u_inlines.h"
  32 #include "util/u_simple_shaders.h"
  33 #include "pipe/p_shader_tokens.h"
  34 }
  35 #include <iostream>
  36 #include <memory>
  37
  38 struct GalliumDXGIOutput;
  39 struct GalliumDXGIAdapter;
  40 struct GalliumDXGISwapChain;
  41 struct GalliumDXGIFactory;
  42
  43 static HRESULT GalliumDXGISwapChainCreate(GalliumDXGIFactory* factory, IUnknown* device, const DXGI_SWAP_CHAIN_DESC& desc, IDXGISwapChain** out_swap_chain);
  44 static HRESULT GalliumDXGIAdapterCreate(GalliumDXGIFactory* adapter, const struct native_platform* platform, void* dpy, IDXGIAdapter1** out_adapter);
  45 static HRESULT GalliumDXGIOutputCreate(GalliumDXGIAdapter* adapter, const std::string& name, const struct native_connector* connector, IDXGIOutput** out_output);
  46 static void GalliumDXGISwapChainRevalidate(IDXGISwapChain* swap_chain);
  47
  48 template<typename Base = IDXGIObject, typename Parent = IDXGIObject>
  49 struct GalliumDXGIObject : public GalliumPrivateDataComObject<Base>
  50 {
  51         ComPtr<Parent> parent;
  52
  53         GalliumDXGIObject(Parent* p_parent = 0)
  54         {
  55                 this->parent = p_parent;
  56         }
  57
  58         virtual HRESULT STDMETHODCALLTYPE GetParent(
  59                 REFIID riid,
  60                 void **out_parent)
  61         {
  62                 return parent->QueryInterface(riid, out_parent);
  63         }
  64 };
  65
  66 COM_INTERFACE(IGalliumDXGIBackend, IUnknown)
  67
  68 // TODO: somehow check whether the window is fully obscured or not
  69 struct GalliumDXGIIdentityBackend : public GalliumComObject<IGalliumDXGIBackend>
  70 {
  71         virtual HRESULT STDMETHODCALLTYPE BeginPresent(
  72                 HWND hwnd,
  73                 void** present_cookie,
  74                 void** window,
  75                 RECT *rect,
  76                 RGNDATA **rgndata,
  77                 BOOL* preserve_aspect_ratio
  78         )
  79         {
  80                 *window = (void*)hwnd;
  81                 rect->left = 0;
  82                 rect->top = 0;
  83                 rect->right = INT_MAX;
  84                 rect->bottom = INT_MAX;
  85                 *rgndata = 0;
  86
  87                 // yes, because we like things looking good
  88                 *preserve_aspect_ratio = TRUE;
  89                 *present_cookie = 0;
  90                 return S_OK;
  91         }
  92
  93         virtual void STDMETHODCALLTYPE EndPresent(
  94                 HWND hwnd,
  95                 void* present_cookie
  96         )
  97         {}
  98
  99         virtual HRESULT STDMETHODCALLTYPE TestPresent(HWND hwnd)
 100         {
 101                 return S_OK;
 102         }
 103
 104         virtual HRESULT STDMETHODCALLTYPE GetPresentSize(
 105                 HWND hwnd,
 106                 unsigned* width,
 107                 unsigned* height
 108         )
 109         {
 110                 *width = 0;
 111                 *height = 0;
 112                 return S_OK;
 113         }
 114 };
 115
 116 // TODO: maybe install an X11 error hook, so we can return errors properly
 117 struct GalliumDXGIX11IdentityBackend : public GalliumDXGIIdentityBackend
 118 {
 119         Display* dpy;
 120
 121         GalliumDXGIX11IdentityBackend(Display* dpy)
 122         : dpy(dpy)
 123         {}
 124
 125         virtual HRESULT STDMETHODCALLTYPE GetPresentSize(
 126                 HWND hwnd,
 127                 unsigned* width,
 128                 unsigned* height
 129         )
 130         {
 131                 XWindowAttributes xwa;
 132                 XGetWindowAttributes(dpy, (Window)hwnd, &xwa);
 133                 *width = xwa.width;
 134                 *height = xwa.height;
 135                 return S_OK;
 136         }
 137 };
 138
 139 struct GalliumDXGIFactory : public GalliumDXGIObject<IDXGIFactory1, IUnknown>
 140 {
 141         HWND associated_window;
 142         const struct native_platform* platform;
 143         void* display;
 144         ComPtr<IGalliumDXGIBackend> backend;
 145         void* resolver_cookie;
 146
 147         GalliumDXGIFactory(const struct native_platform* platform, void* display, IGalliumDXGIBackend* p_backend)
 148         : GalliumDXGIObject<IDXGIFactory1, IUnknown>((IUnknown*)NULL), platform(platform), display(display)
 149          {
 150                 if(p_backend)
 151                         backend = p_backend;
 152                 else if(!strcmp(platform->name, "X11"))
 153                         backend.reset(new GalliumDXGIX11IdentityBackend((Display*)display));
 154                 else
 155                         backend.reset(new GalliumDXGIIdentityBackend());
 156         }
 157
 158         virtual HRESULT STDMETHODCALLTYPE EnumAdapters(
 159                 UINT adapter,
 160                 IDXGIAdapter **out_adapter)
 161         {
 162                 return EnumAdapters1(adapter, (IDXGIAdapter1**)out_adapter);
 163         }
 164
 165         virtual HRESULT STDMETHODCALLTYPE EnumAdapters1(
 166                 UINT adapter,
 167                 IDXGIAdapter1 **out_adapter)
 168         {
 169                 *out_adapter = 0;
 170                 if(adapter == 0)
 171                 {
 172                         return GalliumDXGIAdapterCreate(this, platform, display, out_adapter);
 173                 }
 174 #if 0
 175                 // TODO: enable this
 176                 if(platform == native_get_x11_platform())
 177                 {
 178                         unsigned nscreens = ScreenCount((Display*)display);
 179                         if(adapter < nscreens)
 180                         {
 181                                 unsigned def_screen = DefaultScreen(display);
 182                                 if(adapter <= def_screen)
 183                                         --adapter;
 184                                 *out_adapter = GalliumDXGIAdapterCreate(this, platform, display, adapter);
 185                                 return S_OK;
 186                         }
 187                 }
 188 #endif
 189                 return DXGI_ERROR_NOT_FOUND;
 190         }
 191
 192         /* TODO: this is a mysterious underdocumented magic API
 193          * Can we have multiple windows associated?
 194          * Can we have multiple windows associated if we use multiple factories?
 195          * If so, what should GetWindowAssociation return?
 196          * If not, does a new swapchain steal the association?
 197          * Does this act for existing swapchains? For new swapchains?
 198          */
 199         virtual HRESULT STDMETHODCALLTYPE MakeWindowAssociation(
 200                 HWND window_handle,
 201                 UINT flags)
 202         {
 203                 /* TODO: actually implement, for Wine, X11 and KMS*/
 204                 associated_window = window_handle;
 205                 return S_OK;
 206         }
 207
 208         virtual HRESULT STDMETHODCALLTYPE GetWindowAssociation(
 209                 HWND *pwindow_handle)
 210         {
 211                 *pwindow_handle = associated_window;
 212                 return S_OK;
 213         }
 214
 215         virtual HRESULT STDMETHODCALLTYPE CreateSwapChain(
 216                 IUnknown *device,
 217                 DXGI_SWAP_CHAIN_DESC *desc,
 218                 IDXGISwapChain **out_swap_chain)
 219         {
 220                 return GalliumDXGISwapChainCreate(this, device, *desc, out_swap_chain);
 221         }
 222
 223         virtual HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter(
 224                 HMODULE module,
 225                 IDXGIAdapter **out_adapter)
 226         {
 227                 /* TODO: ignore the module, and just create a Gallium software screen */
 228                 *out_adapter = 0;
 229                 return E_NOTIMPL;
 230         }
 231
 232         /* TODO: support hotplug */
 233         virtual BOOL STDMETHODCALLTYPE IsCurrent( void)
 234         {
 235                 return TRUE;
 236         }
 237 };
 238
 239 struct GalliumDXGIAdapter
 240         : public GalliumMultiComObject<
 241                  GalliumDXGIObject<IDXGIAdapter1, GalliumDXGIFactory>,
 242                  IGalliumAdapter>
 243 {
 244         struct native_display* display;
 245         const struct native_config** configs;
 246         std::unordered_multimap<unsigned, unsigned> configs_by_pipe_format;
 247         std::unordered_map<unsigned, unsigned> configs_by_native_visual_id;
 248         const struct native_connector** connectors;
 249         unsigned num_configs;
 250         DXGI_ADAPTER_DESC1 desc;
 251         std::vector<ComPtr<IDXGIOutput> > outputs;
 252         int num_outputs;
 253
 254         GalliumDXGIAdapter(GalliumDXGIFactory* factory, const struct native_platform* platform, void* dpy)
 255         {
 256                 this->parent = factory;
 257
 258                 display = platform->create_display(dpy, FALSE);
 259                 if(!display)
 260                    display = platform->create_display(dpy, TRUE);
 261                 if (display) {
 262                    display->user_data = this;
 263                    if (!display->init_screen(display)) {
 264                       display->destroy(display);
 265                       display = NULL;
 266                    }
 267                 }
 268                 if(!display)
 269                         throw E_FAIL;
 270                 memset(&desc, 0, sizeof(desc));
 271                 std::string s = std::string("GalliumD3D on ") + display->screen->get_name(display->screen) + " by " + display->screen->get_vendor(display->screen);
 272
 273                 /* hopefully no one will decide to use UTF-8 in Gallium name/vendor strings */
 274                 for(int i = 0; i < std::min((int)s.size(), 127); ++i)
 275                         desc.Description[i] = (WCHAR)s[i];
 276
 277                 // TODO: add an interface to get these; for now, return mid/low values
 278                 desc.DedicatedVideoMemory = 256 << 20;
 279                 desc.DedicatedSystemMemory = 256 << 20;
 280                 desc.SharedSystemMemory = 1024 << 20;
 281
 282                 // TODO: we should actually use an unique ID instead
 283                 *(void**)&desc.AdapterLuid = dpy;
 284
 285                 configs = display->get_configs(display, (int*)&num_configs);
 286                 for(unsigned i = 0; i < num_configs; ++i)
 287                 {
 288                         if(configs[i]->window_bit)
 289                         {
 290                                 configs_by_pipe_format.insert(std::make_pair(configs[i]->color_format, i));
 291                                 configs_by_native_visual_id[configs[i]->native_visual_id] = i;
 292                         }
 293                 }
 294
 295                 connectors = 0;
 296                 num_outputs = 0;
 297
 298                 if(display->modeset)
 299                 {
 300                         int num_crtcs;
 301
 302                         connectors = display->modeset->get_connectors(display, &num_outputs, &num_crtcs);
 303                         if(!connectors)
 304                                 num_outputs = 0;
 305                         else if(!num_outputs)
 306                         {
 307                                 free(connectors);
 308                                 connectors = 0;
 309                         }
 310                 }
 311                 if(!num_outputs)
 312                         num_outputs = 1;
 313         }
 314
 315         static void handle_invalid_surface(struct native_display *ndpy, struct native_surface *nsurf, unsigned int seq_num)
 316         {
 317                 GalliumDXGISwapChainRevalidate((IDXGISwapChain*)nsurf->user_data);
 318         }
 319
 320         ~GalliumDXGIAdapter()
 321         {
 322                 display->destroy(display);
 323                 free(configs);
 324                 free(connectors);
 325         }
 326
 327         virtual HRESULT STDMETHODCALLTYPE EnumOutputs(
 328                 UINT output,
 329                 IDXGIOutput **out_output)
 330         {
 331                 if(output >= (unsigned)num_outputs)
 332                         return DXGI_ERROR_NOT_FOUND;
 333
 334                 if(connectors)
 335                 {
 336                         std::ostringstream ss;
 337                         ss << "output #" << output;
 338                         return GalliumDXGIOutputCreate(this, ss.str(), connectors[output], out_output);
 339                 }
 340                 else
 341                         return GalliumDXGIOutputCreate(this, "Unique output", NULL, out_output);
 342         }
 343
 344         virtual HRESULT STDMETHODCALLTYPE GetDesc(
 345                 DXGI_ADAPTER_DESC *desc)
 346         {
 347                 memcpy(desc, &desc, sizeof(*desc));
 348                 return S_OK;
 349         }
 350
 351         virtual HRESULT STDMETHODCALLTYPE GetDesc1(
 352                 DXGI_ADAPTER_DESC1 *desc)
 353         {
 354                 memcpy(desc, &desc, sizeof(*desc));
 355                 return S_OK;
 356         }
 357
 358         virtual HRESULT STDMETHODCALLTYPE CheckInterfaceSupport(
 359                 REFGUID interface_name,
 360                 LARGE_INTEGER *u_m_d_version)
 361         {
 362                 // these number was taken from Windows 7 with Catalyst 10.8: its meaning is unclear
 363                 if(interface_name == IID_ID3D11Device || interface_name == IID_ID3D10Device1 || interface_name == IID_ID3D10Device)
 364                 {
 365                         u_m_d_version->QuadPart = 0x00080011000a0411ULL;
 366                         return S_OK;
 367                 }
 368                 return DXGI_ERROR_UNSUPPORTED;
 369         }
 370
 371         pipe_screen* STDMETHODCALLTYPE GetGalliumScreen()
 372         {
 373                 return display->screen;
 374         }
 375
 376         pipe_screen* STDMETHODCALLTYPE GetGalliumReferenceSoftwareScreen()
 377         {
 378                 // TODO: give a softpipe screen
 379                 return display->screen;
 380         }
 381
 382         pipe_screen* STDMETHODCALLTYPE GetGalliumFastSoftwareScreen()
 383         {
 384                 // TODO: give an llvmpipe screen
 385                 return display->screen;
 386         }
 387 };
 388
 389
 390 struct GalliumDXGIOutput : public GalliumDXGIObject<IDXGIOutput, GalliumDXGIAdapter>
 391 {
 392         DXGI_OUTPUT_DESC desc;
 393         const struct native_mode** modes;
 394         DXGI_MODE_DESC* dxgi_modes;
 395         unsigned num_modes;
 396         const struct native_connector* connector;
 397         DXGI_GAMMA_CONTROL* gamma;
 398
 399         GalliumDXGIOutput(GalliumDXGIAdapter* adapter, std::string name, const struct native_connector* connector = 0)
 400         : GalliumDXGIObject<IDXGIOutput, GalliumDXGIAdapter>(adapter), connector(connector)
 401         {
 402                 memset(&desc, 0, sizeof(desc));
 403                 for(unsigned i = 0; i < std::min(name.size(), sizeof(desc.DeviceName) - 1); ++i)
 404                         desc.DeviceName[i] = name[i];
 405                 desc.AttachedToDesktop = TRUE;
 406                 /* TODO: should put an HMONITOR in desc.Monitor */
 407
 408                 gamma = 0;
 409                 num_modes = 0;
 410                 modes = 0;
 411                 if(connector)
 412                 {
 413                         modes = parent->display->modeset->get_modes(parent->display, connector, (int*)&num_modes);
 414                         if(modes && num_modes)
 415                         {
 416                                 dxgi_modes = new DXGI_MODE_DESC[num_modes];
 417                                 for(unsigned i = 0; i < num_modes; ++i)
 418                                 {
 419                                         dxgi_modes[i].Width = modes[i]->width;
 420                                         dxgi_modes[i].Height = modes[i]->height;
 421                                         dxgi_modes[i].RefreshRate.Numerator = modes[i]->refresh_rate;
 422                                         dxgi_modes[i].RefreshRate.Denominator = 1;
 423                                         dxgi_modes[i].Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 424                                         dxgi_modes[i].ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 425                                 }
 426                         }
 427                         else
 428                         {
 429                                 if(modes)
 430                                 {
 431                                         free(modes);
 432                                         modes = 0;
 433                                 }
 434                                 goto use_fake_mode;
 435                         }
 436                 }
 437                 else
 438                 {
 439 use_fake_mode:
 440                         dxgi_modes = new DXGI_MODE_DESC[1];
 441                         dxgi_modes[0].Width = 1920;
 442                         dxgi_modes[0].Height = 1200;
 443                         dxgi_modes[0].RefreshRate.Numerator = 60;
 444                         dxgi_modes[0].RefreshRate.Denominator = 1;
 445                         dxgi_modes[0].Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 446                         dxgi_modes[0].ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 447                 }
 448         }
 449
 450         ~GalliumDXGIOutput()
 451         {
 452                 delete [] dxgi_modes;
 453                 free(modes);
 454                 if(gamma)
 455                         delete gamma;
 456         }
 457
 458         virtual HRESULT STDMETHODCALLTYPE GetDesc(
 459                 DXGI_OUTPUT_DESC *out_desc)
 460         {
 461                 *out_desc = desc;
 462                 return S_OK;
 463         }
 464
 465         virtual HRESULT STDMETHODCALLTYPE GetDisplayModeList(
 466                 DXGI_FORMAT enum_format,
 467                 UINT flags,
 468                 UINT *pcount,
 469                 DXGI_MODE_DESC *desc)
 470         {
 471                 /* TODO: should we return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE when we don't
 472                  * support modesetting instead of fake modes?
 473                  */
 474                 pipe_format format = dxgi_to_pipe_format[enum_format];
 475                 if(parent->configs_by_pipe_format.count(format))
 476                 {
 477                         if(!desc)
 478                         {
 479                                 *pcount = num_modes;
 480                                 return S_OK;
 481                         }
 482
 483                         unsigned copy_modes = std::min(num_modes, *pcount);
 484                         for(unsigned i = 0; i < copy_modes; ++i)
 485                         {
 486                                 desc[i] = dxgi_modes[i];
 487                                 desc[i].Format = enum_format;
 488                         }
 489                         *pcount = num_modes;
 490
 491                         if(copy_modes < num_modes)
 492                                 return DXGI_ERROR_MORE_DATA;
 493                         else
 494                                 return S_OK;
 495                 }
 496                 else
 497                 {
 498                         *pcount = 0;
 499                         return S_OK;
 500                 }
 501         }
 502
 503         virtual HRESULT STDMETHODCALLTYPE FindClosestMatchingMode(
 504                 const DXGI_MODE_DESC *pModeToMatch,
 505                 DXGI_MODE_DESC *closest_match,
 506                 IUnknown *concerned_device)
 507         {
 508                 /* TODO: actually implement this */
 509                 DXGI_FORMAT dxgi_format = pModeToMatch->Format;
 510                 enum pipe_format format = dxgi_to_pipe_format[dxgi_format];
 511                 init_pipe_to_dxgi_format();
 512                 if(!parent->configs_by_pipe_format.count(format))
 513                 {
 514                         if(!concerned_device)
 515                                 return E_FAIL;
 516                         else
 517                         {
 518                                 format = parent->configs[0]->color_format;
 519                                 dxgi_format = pipe_to_dxgi_format[format];
 520                         }
 521                 }
 522
 523                 *closest_match = dxgi_modes[0];
 524                 closest_match->Format = dxgi_format;
 525                 return S_OK;
 526         }
 527
 528         virtual HRESULT STDMETHODCALLTYPE WaitForVBlank( void)
 529         {
 530                 return S_OK;
 531         }
 532
 533         virtual HRESULT STDMETHODCALLTYPE TakeOwnership(
 534                 IUnknown *device,
 535                 BOOL exclusive)
 536         {
 537                 return S_OK;
 538         }
 539
 540         virtual void STDMETHODCALLTYPE ReleaseOwnership( void)
 541         {
 542         }
 543
 544         virtual HRESULT STDMETHODCALLTYPE GetGammaControlCapabilities(
 545                 DXGI_GAMMA_CONTROL_CAPABILITIES *gamma_caps)
 546         {
 547                 memset(gamma_caps, 0, sizeof(*gamma_caps));
 548                 return S_OK;
 549         }
 550
 551         virtual HRESULT STDMETHODCALLTYPE SetGammaControl(
 552                         const DXGI_GAMMA_CONTROL *pArray)
 553         {
 554                 if(!gamma)
 555                         gamma = new DXGI_GAMMA_CONTROL;
 556                 *gamma = *pArray;
 557                 return S_OK;
 558         }
 559
 560         virtual HRESULT STDMETHODCALLTYPE GetGammaControl(
 561                         DXGI_GAMMA_CONTROL *pArray)
 562         {
 563                 if(gamma)
 564                         *pArray = *gamma;
 565                 else
 566                 {
 567                         pArray->Scale.Red = 1;
 568                         pArray->Scale.Green = 1;
 569                         pArray->Scale.Blue = 1;
 570                         pArray->Offset.Red = 0;
 571                         pArray->Offset.Green = 0;
 572                         pArray->Offset.Blue = 0;
 573                         for(unsigned i = 0; i <= 1024; ++i)
 574                                 pArray->GammaCurve[i].Red = pArray->GammaCurve[i].Green = pArray->GammaCurve[i].Blue = (float)i / 1024.0;
 575                 }
 576                 return S_OK;
 577         }
 578
 579         virtual HRESULT STDMETHODCALLTYPE SetDisplaySurface(
 580                 IDXGISurface *scanout_surface)
 581         {
 582                 return E_NOTIMPL;
 583         }
 584
 585         virtual HRESULT STDMETHODCALLTYPE GetDisplaySurfaceData(
 586                 IDXGISurface *destination)
 587         {
 588                 return E_NOTIMPL;
 589         }
 590
 591         virtual HRESULT STDMETHODCALLTYPE GetFrameStatistics(
 592                 DXGI_FRAME_STATISTICS *stats)
 593         {
 594                 memset(stats, 0, sizeof(*stats));
 595 #ifdef _WIN32
 596                 QueryPerformanceCounter(&stats->SyncQPCTime);
 597 #endif
 598                 return E_NOTIMPL;
 599         }
 600 };
 601
 602 /* Swap chain are rather complex, and Microsoft's documentation is rather
 603  * lacking. As far as I know, this is the most thorough publicly available
 604  * description of how swap chains work, based on multiple sources and
 605  * experimentation.
 606  *
 607  * There are two modes (called "swap effects") that a swap chain can operate in:
 608  * discard and sequential.
 609  *
 610  * In discard mode, things always look as if there is a single buffer, which
 611  * you can get with GetBuffers(0).
 612  * The 2D texture returned by GetBuffers(0) and can only be
 613  * used as a render target view and for resource copies, since no CPU access
 614  * flags are set and only the D3D11_BIND_RENDER_TARGET bind flag is set.
 615  * On Present, it is copied to the actual display
 616  * surface and the contents become undefined.
 617  * D3D may internally use multiple buffers, but you can't observe this, except
 618  * by looking at the buffer contents after Present (but those are undefined).
 619  * If it uses multiple buffers internally, then it will normally use buffer_count buffers
 620  * (this has latency implications).
 621  * Discard mode seems to internally use a single buffer in windowed mode,
 622  * even if DWM is enabled, and buffer_count buffers in fullscreen mode.
 623  *
 624  * In sequential mode, the runtime alllocates buffer_count buffers.
 625  * You can get each with GetBuffers(n).
 626  * GetBuffers(0) ALWAYS points to the backbuffer to be presented and has the
 627  * same usage constraints as the discard mode.
 628  * GetBuffer(n) with n > 0 points to resources that are identical to buffer 0, but
 629  * are classified as "read-only resources" (due to DXGI_USAGE_READ_ONLY),
 630  * meaning that you can't create render target views on them, or use them as
 631  * a CopyResource/CopySubresourceRegion destination.
 632  * It appears the only valid operation is to use them as a source for CopyResource
 633  * and CopySubresourceRegion as well as just waiting for them to become
 634  * buffer 0 again.
 635  * Buffer n - 1 is always displayed on screen.
 636  * When you call Present(), the contents of the buffers are rotated, so that buffer 0
 637  * goes to buffer n - 1, and is thus displayed, and buffer 1 goes to buffer 0, becomes
 638  * the accessible back buffer.
 639  * The resources themselves are NOT rotated, so that you can still render on the
 640  * same ID3D11Texture2D*, and views based on it, that you got before Present().
 641  *
 642  * Present seems to happen by either copying the relevant buffer into the window,
 643  * or alternatively making it the current one, either by programming the CRTC or
 644  * by sending the resource name to the DWM compositor.
 645  *
 646  * Hence, you can call GetBuffer(0) once and keep using the same ID3D11Texture2D*
 647  * and ID3D11RenderTargetView* (and other views if needed) you got from it.
 648  *
 649  * If the window gets resized, DXGI will then "emulate" all successive presentations,
 650  * by using a stretched blit automatically.
 651  * Thus, you should handle WM_SIZE and call ResizeBuffers to update the DXGI
 652  * swapchain buffers size to the new window size.
 653  * Doing so requires you to release all GetBuffers() results and anything referencing
 654  * them, including views and Direct3D11 deferred context command lists (this is
 655  * documented).
 656  *
 657  * How does Microsoft implement the rotation behavior?
 658  * It turns out that it does it by calling RotateResourceIdentitiesDXGI in the user-mode
 659  * DDI driver.
 660  * This will rotate the kernel buffer handle, or possibly rotate the GPU virtual memory
 661  * mappings.
 662  *
 663  * The reason this is done by driver instead of by the runtime appears to be that
 664  * this is necessary to support driver-provided command list support, since otherwise
 665  * the command list would not always target the current backbuffer, since it would
 666  * be done at the driver level, while only the runtime knows about the rotation.
 667  *
 668  * OK, so how do we implement this in Gallium?
 669  *
 670  * There are three strategies:
 671  * 1. Use a single buffer, and always copy it to a window system provided buffer, or
 672  *      just give the buffer to the window system if it supports that
 673  * 2. Rotate the buffers in the D3D1x implementation, and recreate and rebind the views.
 674  *       Don't support driver-provided command lists
 675  * 3. Add this rotation functionality to the Gallium driver, with the idea that it would rotate
 676  *      remap GPU virtual memory, so that virtual address are unchanged, but the physical
 677  *      ones are rotated (so that pushbuffers remain valid).
 678  *      If the driver does not support this, either fall back to (1), or have a layer doing this,
 679  *      putting a deferred context layer over this intermediate layer.
 680  *
 681  * (2) is not acceptable since it prevents an optimal implementation.
 682  * (3) is the ideal solution, but it is complicated.
 683  *
 684  * Hence, we implement (1) for now, and will switch to (3) later.
 685  *
 686  * Note that (1) doesn't really work for DXGI_SWAP_EFFECT_SEQUENTIAL with more
 687  * than one buffer, so we just pretend we got asked for a single buffer in that case
 688  * Fortunately, no one seems to rely on that, so we'll just not implement it at first, and
 689  * later perform the rotation with blits.
 690  * Once we switch to (3), we'll just use real rotation to do it..
 691  *
 692  * DXGI_SWAP_EFFECT_SEQUENTIAL with more than one buffer is of dubious use
 693  * anyway, since you can only render or write to buffer 0, and other buffers can apparently
 694  * be used only as sources for copies.
 695  * I was unable to find any code using it either in DirectX SDK examples, or on the web.
 696  *
 697  * It seems the only reason you would use it is to not have to redraw from scratch, while
 698  * also possibly avoid a copy compared to buffer_count == 1, assuming that your
 699  * application is OK with having to redraw starting not from the last frame, but from
 700  * one/two/more frames behind it.
 701  *
 702  * A better design would forbid the user specifying buffer_count explicitly, and
 703  * would instead let the application give an upper bound on how old the buffer can
 704  * become after presentation, with "infinite" being equivalent to discard.
 705  * The runtime would then tell the application with frame number the buffer switched to
 706  * after present.
 707  * In addition, in a better design, the application would be allowed to specify the
 708  * number of buffers available, having all them usable for rendering, so that things
 709  * like video players could efficiently decode frames in parallel.
 710  * Present would in such a better design gain a way to specify the number of buffers
 711  * to present.
 712  *
 713  * Other miscellaneous info:
 714  * DXGI_PRESENT_DO_NOT_SEQUENCE causes DXGI to hold the frame for another
 715  * vblank interval without rotating the resource data.
 716  *
 717  * References:
 718  * "DXGI Overview" in MSDN
 719  * IDXGISwapChain documentation on MSDN
 720  * "RotateResourceIdentitiesDXGI" on MSDN
 721  * http://forums.xna.com/forums/p/42362/266016.aspx
 722  */
 723
 724 static float quad_data[] = {
 725         -1, -1, 0, 0,
 726         -1, 1, 0, 1,
 727         1, 1, 1, 1,
 728         1, -1, 1, 0,
 729 };
 730
 731 struct dxgi_blitter
 732 {
 733         pipe_context* pipe;
 734         bool normalized;
 735         void* fs;
 736         void* vs;
 737         void* sampler[2];
 738         void* elements;
 739         void* blend;
 740         void* rasterizer;
 741         void* zsa;
 742         struct pipe_clip_state clip;
 743         struct pipe_vertex_buffer vbuf;
 744         struct pipe_draw_info draw;
 745
 746         dxgi_blitter(pipe_context* pipe)
 747         : pipe(pipe)
 748         {
 749                 //normalized = !!pipe->screen->get_param(pipe, PIPE_CAP_NPOT_TEXTURES);
 750                 // TODO: need to update buffer in unnormalized case
 751                 normalized = true;
 752
 753                 struct pipe_rasterizer_state rs_state;
 754                 memset(&rs_state, 0, sizeof(rs_state));
 755                 rs_state.cull_face = PIPE_FACE_NONE;
 756                 rs_state.gl_rasterization_rules = 1;
 757                 rs_state.depth_clip = 1;
 758                 rs_state.flatshade = 1;
 759                 rasterizer = pipe->create_rasterizer_state(pipe, &rs_state);
 760
 761                 struct pipe_blend_state blendd;
 762                 memset(&blendd, 0, sizeof(blendd));
 763                 blendd.rt[0].colormask = PIPE_MASK_RGBA;
 764                 blend = pipe->create_blend_state(pipe, &blendd);
 765
 766                 struct pipe_depth_stencil_alpha_state zsad;
 767                 memset(&zsad, 0, sizeof(zsad));
 768                 zsa = pipe->create_depth_stencil_alpha_state(pipe, &zsad);
 769
 770                 struct pipe_vertex_element velem[2];
 771                 memset(&velem[0], 0, sizeof(velem[0]) * 2);
 772                 velem[0].src_offset = 0;
 773                 velem[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
 774                 velem[1].src_offset = 8;
 775                 velem[1].src_format = PIPE_FORMAT_R32G32_FLOAT;
 776                 elements = pipe->create_vertex_elements_state(pipe, 2, &velem[0]);
 777
 778                 for(unsigned stretch = 0; stretch < 2; ++stretch)
 779                 {
 780                         struct pipe_sampler_state sampler_state;
 781                         memset(&sampler_state, 0, sizeof(sampler_state));
 782                         sampler_state.min_img_filter = stretch ? PIPE_TEX_FILTER_LINEAR : PIPE_TEX_FILTER_NEAREST;
 783                         sampler_state.mag_img_filter = stretch ? PIPE_TEX_FILTER_LINEAR : PIPE_TEX_FILTER_NEAREST;
 784                         sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 785                         sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 786                         sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 787                         sampler_state.normalized_coords = normalized;
 788
 789                         sampler[stretch] = pipe->create_sampler_state(pipe, &sampler_state);
 790                 }
 791
 792                 fs = util_make_fragment_tex_shader(pipe, normalized ? TGSI_TEXTURE_2D : TGSI_TEXTURE_RECT, TGSI_INTERPOLATE_LINEAR);
 793
 794                 const unsigned semantic_names[] = { TGSI_SEMANTIC_POSITION, TGSI_SEMANTIC_GENERIC };
 795                 const unsigned semantic_indices[] = { 0, 0 };
 796                 vs = util_make_vertex_passthrough_shader(pipe, 2, semantic_names, semantic_indices);
 797
 798                 vbuf.buffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,
 799                                                  PIPE_USAGE_STREAM, sizeof(quad_data));
 800                 vbuf.buffer_offset = 0;
 801                 vbuf.stride = 4 * sizeof(float);
 802                 pipe_buffer_write(pipe, vbuf.buffer, 0, sizeof(quad_data), quad_data);
 803
 804                 memset(&clip, 0, sizeof(clip));
 805
 806                 memset(&draw, 0, sizeof(draw));
 807                 draw.mode = PIPE_PRIM_QUADS;
 808                 draw.count = 4;
 809                 draw.instance_count = 1;
 810                 draw.max_index = ~0;
 811         }
 812
 813         void blit(struct pipe_surface* surf, struct pipe_sampler_view* view, unsigned x, unsigned y, unsigned w, unsigned h)
 814         {
 815                 struct pipe_framebuffer_state fb;
 816                 memset(&fb, 0, sizeof(fb));
 817                 fb.nr_cbufs = 1;
 818                 fb.cbufs[0] = surf;
 819                 fb.width = surf->width;
 820                 fb.height = surf->height;
 821
 822                 struct pipe_viewport_state viewport;
 823                 float half_width = w * 0.5f;
 824                 float half_height = h * 0.5f;
 825                 viewport.scale[0] = half_width;
 826                 viewport.scale[1] = half_height;
 827                 viewport.scale[2] = 1.0f;
 828                 viewport.scale[3] = 1.0f;
 829                 viewport.translate[0] = x + half_width;
 830                 viewport.translate[1] = y + half_height;
 831                 viewport.translate[2] = 0.0f;
 832                 viewport.translate[3] = 1.0f;
 833
 834                 bool stretch = view->texture->width0 != w || view->texture->height0 != h;
 835                 if(pipe->render_condition)
 836                         pipe->render_condition(pipe, 0, 0);
 837                 pipe->set_framebuffer_state(pipe, &fb);
 838                 pipe->bind_fragment_sampler_states(pipe, 1, &sampler[stretch]);
 839                 pipe->set_viewport_state(pipe, &viewport);
 840                 pipe->set_clip_state(pipe, &clip);
 841                 pipe->bind_rasterizer_state(pipe, rasterizer);
 842                 pipe->bind_depth_stencil_alpha_state(pipe, zsa);
 843                 pipe->bind_blend_state(pipe, blend);
 844                 pipe->bind_vertex_elements_state(pipe, elements);
 845                 pipe->set_vertex_buffers(pipe, 1, &vbuf);
 846                 pipe->bind_fs_state(pipe, fs);
 847                 pipe->bind_vs_state(pipe, vs);
 848                 if(pipe->bind_gs_state)
 849                         pipe->bind_gs_state(pipe, 0);
 850                 if(pipe->set_stream_output_targets)
 851                         pipe->set_stream_output_targets(pipe, 0, NULL, 0);
 852                 pipe->set_fragment_sampler_views(pipe, 1, &view);
 853
 854                 pipe->draw_vbo(pipe, &draw);
 855         }
 856
 857         ~dxgi_blitter()
 858         {
 859                 pipe->delete_blend_state(pipe, blend);
 860                 pipe->delete_rasterizer_state(pipe, rasterizer);
 861                 pipe->delete_depth_stencil_alpha_state(pipe, zsa);
 862                 pipe->delete_sampler_state(pipe, sampler[0]);
 863                 pipe->delete_sampler_state(pipe, sampler[1]);
 864                 pipe->delete_vertex_elements_state(pipe, elements);
 865                 pipe->delete_vs_state(pipe, vs);
 866                 pipe->delete_fs_state(pipe, fs);
 867                 pipe->screen->resource_destroy(pipe->screen, vbuf.buffer);
 868         }
 869 };
 870
 871 struct GalliumDXGISwapChain : public GalliumDXGIObject<IDXGISwapChain, GalliumDXGIFactory>
 872 {
 873         ComPtr<IDXGIDevice>dxgi_device;
 874         ComPtr<IGalliumDevice>gallium_device;
 875         ComPtr<GalliumDXGIAdapter> adapter;
 876         ComPtr<IDXGIOutput> target;
 877
 878         DXGI_SWAP_CHAIN_DESC desc;
 879
 880         struct native_surface* surface;
 881         const struct native_config* config;
 882
 883         void* window;
 884         struct pipe_resource* resources[NUM_NATIVE_ATTACHMENTS];
 885         int width;
 886         int height;
 887         unsigned seq_num;
 888         bool ever_validated;
 889         bool needs_validation;
 890         unsigned present_count;
 891
 892         ComPtr<IDXGISurface> buffer0;
 893         struct pipe_resource* gallium_buffer0;
 894         struct pipe_sampler_view* gallium_buffer0_view;
 895
 896         struct pipe_context* pipe;
 897         bool owns_pipe;
 898
 899         BOOL fullscreen;
 900
 901         std::auto_ptr<dxgi_blitter> blitter;
 902         bool formats_compatible;
 903
 904         GalliumDXGISwapChain(GalliumDXGIFactory* factory, IUnknown* p_device, const DXGI_SWAP_CHAIN_DESC& p_desc)
 905         : GalliumDXGIObject<IDXGISwapChain, GalliumDXGIFactory>(factory), desc(p_desc), surface(0)
 906         {
 907                 HRESULT hr;
 908
 909                 hr = p_device->QueryInterface(IID_IGalliumDevice, (void**)&gallium_device);
 910                 if(!SUCCEEDED(hr))
 911                         throw hr;
 912
 913                 hr = p_device->QueryInterface(IID_IDXGIDevice, (void**)&dxgi_device);
 914                 if(!SUCCEEDED(hr))
 915                         throw hr;
 916
 917                 hr = dxgi_device->GetAdapter((IDXGIAdapter**)&adapter);
 918                 if(!SUCCEEDED(hr))
 919                         throw hr;
 920
 921                 memset(resources, 0, sizeof(resources));
 922
 923                 if(desc.SwapEffect == DXGI_SWAP_EFFECT_SEQUENTIAL && desc.BufferCount != 1)
 924                 {
 925                         std::cerr << "Gallium DXGI: if DXGI_SWAP_EFFECT_SEQUENTIAL is specified, only buffer_count == 1 is implemented, but " << desc.BufferCount << " was specified: ignoring this" << std::endl;
 926                         // change the returned desc, so that the application might perhaps notice what we did and react well
 927                         desc.BufferCount = 1;
 928                 }
 929
 930                 pipe = gallium_device->GetGalliumContext();
 931                 owns_pipe = false;
 932                 if(!pipe)
 933                 {
 934                         pipe = adapter->display->screen->context_create(adapter->display->screen, 0);
 935                         owns_pipe = true;
 936                 }
 937
 938                 blitter.reset(new dxgi_blitter(pipe));
 939                 window = 0;
 940
 941                 hr = resolve_zero_width_height(true);
 942                 if(!SUCCEEDED(hr))
 943                         throw hr;
 944         }
 945
 946         void init_for_window()
 947         {
 948                 if(surface)
 949                 {
 950                         surface->destroy(surface);
 951                         surface = 0;
 952                 }
 953
 954                 unsigned config_num;
 955                 if(!strcmp(parent->platform->name, "X11"))
 956                 {
 957                         XWindowAttributes xwa;
 958                         XGetWindowAttributes((Display*)parent->display, (Window)window, &xwa);
 959                         assert(adapter->configs_by_native_visual_id.count(xwa.visual->visualid));
 960                         config_num = adapter->configs_by_native_visual_id[xwa.visual->visualid];
 961                 }
 962                 else
 963                 {
 964                         enum pipe_format format = dxgi_to_pipe_format[desc.BufferDesc.Format];
 965                         if(!adapter->configs_by_pipe_format.count(format))
 966                         {
 967                                 if(adapter->configs_by_pipe_format.empty())
 968                                         throw E_FAIL;
 969                                 // TODO: choose the best match
 970                                 format = (pipe_format)adapter->configs_by_pipe_format.begin()->first;
 971                         }
 972                         // TODO: choose the best config
 973                         config_num = adapter->configs_by_pipe_format.find(format)->second;
 974                 }
 975
 976                 config = adapter->configs[config_num];
 977                 surface = adapter->display->create_window_surface(adapter->display, (EGLNativeWindowType)window, config);
 978                 surface->user_data = this;
 979
 980                 width = 0;
 981                 height = 0;
 982                 seq_num = 0;
 983                 present_count = 0;
 984                 needs_validation = true;
 985                 ever_validated = false;
 986
 987                 formats_compatible = util_is_format_compatible(
 988                                 util_format_description(dxgi_to_pipe_format[desc.BufferDesc.Format]),
 989                                 util_format_description(config->color_format));
 990         }
 991
 992         ~GalliumDXGISwapChain()
 993         {
 994                 if(owns_pipe)
 995                         pipe->destroy(pipe);
 996         }
 997
 998         virtual HRESULT STDMETHODCALLTYPE GetDevice(
 999                 REFIID riid,
1000                 void **pdevice)
1001         {
1002                 return dxgi_device->QueryInterface(riid, pdevice);
1003         }
1004
1005         HRESULT create_buffer0()
1006         {
1007                 HRESULT hr;
1008                 ComPtr<IDXGISurface> new_buffer0;
1009                 DXGI_USAGE usage = DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_RENDER_TARGET_OUTPUT;
1010                 if(desc.SwapEffect == DXGI_SWAP_EFFECT_DISCARD)
1011                         usage |= DXGI_USAGE_DISCARD_ON_PRESENT;
1012                 // for our blitter
1013                 usage |= DXGI_USAGE_SHADER_INPUT;
1014
1015                 DXGI_SURFACE_DESC surface_desc;
1016                 surface_desc.Format = desc.BufferDesc.Format;
1017                 surface_desc.Width = desc.BufferDesc.Width;
1018                 surface_desc.Height = desc.BufferDesc.Height;
1019                 surface_desc.SampleDesc = desc.SampleDesc;
1020                 hr = dxgi_device->CreateSurface(&surface_desc, 1, usage, 0, &new_buffer0);
1021                 if(!SUCCEEDED(hr))
1022                         return hr;
1023
1024                 ComPtr<IGalliumResource> gallium_resource;
1025                 hr = new_buffer0->QueryInterface(IID_IGalliumResource, (void**)&gallium_resource);
1026                 if(!SUCCEEDED(hr))
1027                         return hr;
1028
1029                 struct pipe_resource* new_gallium_buffer0 = gallium_resource->GetGalliumResource();
1030                 if(!new_gallium_buffer0)
1031                         return E_FAIL;
1032
1033                 buffer0.reset(new_buffer0.steal());
1034                 gallium_buffer0 = new_gallium_buffer0;
1035                 struct pipe_sampler_view templat;
1036                 memset(&templat, 0, sizeof(templat));
1037                 templat.texture = gallium_buffer0;
1038                 templat.swizzle_r = 0;
1039                 templat.swizzle_g = 1;
1040                 templat.swizzle_b = 2;
1041                 templat.swizzle_a = 3;
1042                 templat.format = gallium_buffer0->format;
1043                 gallium_buffer0_view = pipe->create_sampler_view(pipe, gallium_buffer0, &templat);
1044                 return S_OK;
1045         }
1046
1047         bool validate()
1048         {
1049                 unsigned new_seq_num;
1050                 needs_validation = false;
1051
1052                 if(!surface->validate(surface, (1 << NATIVE_ATTACHMENT_BACK_LEFT) | (1 << NATIVE_ATTACHMENT_FRONT_LEFT), &new_seq_num, resources, &width, &height))
1053                         return false;
1054
1055                 if(!ever_validated || seq_num != new_seq_num)
1056                 {
1057                         seq_num = new_seq_num;
1058                         ever_validated = true;
1059                 }
1060                 return true;
1061         }
1062
1063         HRESULT resolve_zero_width_height(bool force = false)
1064         {
1065                 if(!force && desc.BufferDesc.Width && desc.BufferDesc.Height)
1066                         return S_OK;
1067
1068                 unsigned width, height;
1069                 HRESULT hr = parent->backend->GetPresentSize(desc.OutputWindow, &width, &height);
1070                 if(!SUCCEEDED(hr))
1071                         return hr;
1072
1073                 // On Windows, 8 is used, and a debug message saying so gets printed
1074                 if(!width)
1075                         width = 8;
1076                 if(!height)
1077                         height = 8;
1078
1079                 if(!desc.BufferDesc.Width)
1080                         desc.BufferDesc.Width = width;
1081                 if(!desc.BufferDesc.Height)
1082                         desc.BufferDesc.Height = height;
1083                 return S_OK;
1084         }
1085
1086         virtual HRESULT STDMETHODCALLTYPE Present(
1087                 UINT sync_interval,
1088                 UINT flags)
1089         {
1090                 HRESULT hr;
1091                 if(flags & DXGI_PRESENT_TEST)
1092                         return parent->backend->TestPresent(desc.OutputWindow);
1093
1094                 if(!buffer0)
1095                 {
1096                         HRESULT hr = create_buffer0();
1097                         if(!SUCCEEDED(hr))
1098                                 return hr;
1099                 }
1100
1101                 void* cur_window = 0;
1102                 RECT rect;
1103                 RGNDATA* rgndata;
1104                 BOOL preserve_aspect_ratio;
1105                 unsigned dst_w, dst_h;
1106                 bool db;
1107                 struct pipe_resource* dst;
1108                 struct pipe_resource* src;
1109                 struct pipe_surface* dst_surface;
1110                 struct native_present_control ctrl;
1111
1112                 void* present_cookie;
1113                 hr = parent->backend->BeginPresent(desc.OutputWindow, &present_cookie, &cur_window, &rect, &rgndata, &preserve_aspect_ratio);
1114                 if(hr != S_OK)
1115                         return hr;
1116
1117                 if(!cur_window || rect.left >= rect.right || rect.top >= rect.bottom)
1118                         goto end_present;
1119
1120                 if(cur_window != window)
1121                 {
1122                         window = cur_window;
1123                         init_for_window();
1124                 }
1125
1126                 if(needs_validation)
1127                 {
1128                         if(!validate())
1129                                 return DXGI_ERROR_DEVICE_REMOVED;
1130                 }
1131
1132                 db = !!(config->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT));
1133                 dst = resources[db ? NATIVE_ATTACHMENT_BACK_LEFT : NATIVE_ATTACHMENT_FRONT_LEFT];
1134                 src = gallium_buffer0;
1135                 dst_surface = 0;
1136
1137                 assert(src);
1138                 assert(dst);
1139
1140                 /* TODO: sharing the context for blitting won't work correctly if queries are active
1141                  * Hopefully no one is crazy enough to keep queries active while presenting, expecting
1142                  * sensible results.
1143                  * We could alternatively force using another context, but that might cause inefficiency issues
1144                  */
1145
1146                 if((unsigned)rect.right > dst->width0)
1147                         rect.right = dst->width0;
1148                 if((unsigned)rect.bottom > dst->height0)
1149                         rect.bottom = dst->height0;
1150                 if(rect.left > rect.right)
1151                         rect.left = rect.right;
1152                 if(rect.top > rect.bottom)
1153                         rect.top = rect.bottom;
1154
1155                 if(rect.left >= rect.right && rect.top >= rect.bottom)
1156                         goto end_present;
1157
1158                 dst_w = rect.right - rect.left;
1159                 dst_h = rect.bottom - rect.top;
1160
1161                 // TODO: add support for rgndata
1162 //              if(preserve_aspect_ratio || !rgndata)
1163                 if(1)
1164                 {
1165                         unsigned blit_x, blit_y, blit_w, blit_h;
1166                         static const union pipe_color_union black = { { 0, 0, 0, 0 } };
1167
1168                         if(!formats_compatible || src->width0 != dst_w || src->height0 != dst_h) {
1169                                 struct pipe_surface templat;
1170                                 templat.usage = PIPE_BIND_RENDER_TARGET;
1171                                 templat.format = dst->format;
1172                                 templat.u.tex.level = 0;
1173                                 templat.u.tex.first_layer = 0;
1174                                 templat.u.tex.last_layer = 0;
1175                                 dst_surface = pipe->create_surface(pipe, dst, &templat);
1176                         }
1177
1178                         if(preserve_aspect_ratio)
1179                         {
1180                                 int delta = src->width0 * dst_h - dst_w * src->height0;
1181                                 if(delta > 0)
1182                                 {
1183                                         blit_w = dst_w;
1184                                         blit_h = dst_w * src->height0 / src->width0;
1185                                 }
1186                                 else if(delta < 0)
1187                                 {
1188                                         blit_w = dst_h * src->width0 / src->height0;
1189                                         blit_h = dst_h;
1190                                 }
1191                                 else
1192                                 {
1193                                         blit_w = dst_w;
1194                                         blit_h = dst_h;
1195                                 }
1196
1197                                 blit_x = (dst_w - blit_w) >> 1;
1198                                 blit_y = (dst_h - blit_h) >> 1;
1199                         }
1200                         else
1201                         {
1202                                 blit_x = 0;
1203                                 blit_y = 0;
1204                                 blit_w = dst_w;
1205                                 blit_h = dst_h;
1206                         }
1207
1208                         if(blit_x)
1209                                 pipe->clear_render_target(pipe, dst_surface, &black, rect.left, rect.top, blit_x, dst_h);
1210                         if(blit_y)
1211                                 pipe->clear_render_target(pipe, dst_surface, &black, rect.left, rect.top, dst_w, blit_y);
1212
1213                         if(formats_compatible && blit_w == src->width0 && blit_h == src->height0)
1214                         {
1215                                 pipe_box box;
1216                                 box.x = box.y = box.z = 0;
1217                                 box.width = blit_w;
1218                                 box.height = blit_h;
1219                                 box.depth = 1;
1220                                 pipe->resource_copy_region(pipe, dst, 0, rect.left, rect.top, 0, src, 0, &box);
1221                         }
1222                         else
1223                         {
1224                                 blitter->blit(dst_surface, gallium_buffer0_view, rect.left + blit_x, rect.top + blit_y, blit_w, blit_h);
1225                                 if(!owns_pipe)
1226                                         gallium_device->RestoreGalliumState();
1227                         }
1228
1229                         if(blit_w != dst_w)
1230                                 pipe->clear_render_target(pipe, dst_surface, &black, rect.left + blit_x + blit_w, rect.top, dst_w - blit_x - blit_w, dst_h);
1231                         if(blit_h != dst_h)
1232                                 pipe->clear_render_target(pipe, dst_surface, &black, rect.left, rect.top + blit_y + blit_h, dst_w, dst_h - blit_y - blit_h);
1233                 }
1234
1235                 if(dst_surface)
1236                         pipe->surface_destroy(pipe, dst_surface);
1237
1238                 pipe->flush(pipe, 0);
1239
1240                 memset(&ctrl, 0, sizeof(ctrl));
1241                 ctrl.natt = (db) ? NATIVE_ATTACHMENT_BACK_LEFT : NATIVE_ATTACHMENT_FRONT_LEFT;
1242                 if(!surface->present(surface, &ctrl))
1243                         return DXGI_ERROR_DEVICE_REMOVED;
1244
1245 end_present:
1246                 parent->backend->EndPresent(desc.OutputWindow, present_cookie);
1247
1248                 ++present_count;
1249                 return S_OK;
1250         }
1251
1252         virtual HRESULT STDMETHODCALLTYPE GetBuffer(
1253                         UINT Buffer,
1254                         REFIID riid,
1255                         void **ppSurface)
1256         {
1257                 if(Buffer > 0)
1258                 {
1259                         if(desc.SwapEffect == DXGI_SWAP_EFFECT_SEQUENTIAL)
1260                                 std::cerr << "DXGI unimplemented: GetBuffer(n) with n > 0 not supported, returning buffer 0 instead!" << std::endl;
1261                         else
1262                                 std::cerr << "DXGI error: in GetBuffer(n), n must be 0 for DXGI_SWAP_EFFECT_DISCARD\n" << std::endl;
1263                 }
1264
1265                 if(!buffer0)
1266                 {
1267                         HRESULT hr = create_buffer0();
1268                         if(!SUCCEEDED(hr))
1269                                 return hr;
1270                 }
1271                 return buffer0->QueryInterface(riid, ppSurface);
1272         }
1273
1274         /* TODO: implement somehow */
1275         virtual HRESULT STDMETHODCALLTYPE SetFullscreenState(
1276                 BOOL fullscreen,
1277                 IDXGIOutput *target)
1278         {
1279                 fullscreen = fullscreen;
1280                 target = target;
1281                 return S_OK;
1282         }
1283
1284         virtual HRESULT STDMETHODCALLTYPE GetFullscreenState(
1285                 BOOL *out_fullscreen,
1286                 IDXGIOutput **out_target)
1287         {
1288                 if(out_fullscreen)
1289                         *out_fullscreen = fullscreen;
1290                 if(out_target)
1291                         *out_target = target.ref();
1292                 return S_OK;
1293         }
1294
1295         virtual HRESULT STDMETHODCALLTYPE GetDesc(
1296                 DXGI_SWAP_CHAIN_DESC *out_desc)
1297         {
1298                 *out_desc = desc;
1299                 return S_OK;
1300         }
1301
1302         virtual HRESULT STDMETHODCALLTYPE ResizeBuffers(
1303                 UINT buffer_count,
1304                 UINT width,
1305                 UINT height,
1306                 DXGI_FORMAT new_format,
1307                 UINT swap_chain_flags)
1308         {
1309                 if(buffer0)
1310                 {
1311                         buffer0.p->AddRef();
1312                         ULONG v = buffer0.p->Release();
1313                         // we must fail if there are any references to buffer0 other than ours
1314                         if(v > 1)
1315                                 return E_FAIL;
1316                         pipe_sampler_view_reference(&gallium_buffer0_view, 0);
1317                         buffer0 = (IUnknown*)NULL;
1318                         gallium_buffer0 = 0;
1319                 }
1320
1321                 if(desc.SwapEffect != DXGI_SWAP_EFFECT_SEQUENTIAL)
1322                         desc.BufferCount = buffer_count;
1323                 desc.BufferDesc.Format = new_format;
1324                 desc.BufferDesc.Width = width;
1325                 desc.BufferDesc.Height = height;
1326                 desc.Flags = swap_chain_flags;
1327                 return resolve_zero_width_height();
1328         }
1329
1330         virtual HRESULT STDMETHODCALLTYPE ResizeTarget(
1331                 const DXGI_MODE_DESC *out_new_target_parameters)
1332         {
1333                 /* TODO: implement */
1334                 return S_OK;
1335         }
1336
1337         virtual HRESULT STDMETHODCALLTYPE GetContainingOutput(
1338                 IDXGIOutput **out_output)
1339         {
1340                 *out_output = adapter->outputs[0].ref();
1341                 return S_OK;
1342         }
1343
1344         virtual HRESULT STDMETHODCALLTYPE GetFrameStatistics(
1345                 DXGI_FRAME_STATISTICS *out_stats)
1346         {
1347                 memset(out_stats, 0, sizeof(*out_stats));
1348 #ifdef _WIN32
1349                 QueryPerformanceCounter(&out_stats->SyncQPCTime);
1350 #endif
1351                 out_stats->PresentCount = present_count;
1352                 out_stats->PresentRefreshCount = present_count;
1353                 out_stats->SyncRefreshCount = present_count;
1354                 return S_OK;
1355         }
1356
1357         virtual HRESULT STDMETHODCALLTYPE GetLastPresentCount(
1358                 UINT *last_present_count)
1359         {
1360                 *last_present_count = present_count;
1361                 return S_OK;
1362         }
1363 };
1364
1365 static void GalliumDXGISwapChainRevalidate(IDXGISwapChain* swap_chain)
1366 {
1367         ((GalliumDXGISwapChain*)swap_chain)->needs_validation = true;
1368 }
1369
1370 static HRESULT GalliumDXGIAdapterCreate(GalliumDXGIFactory* factory, const struct native_platform* platform, void* dpy, IDXGIAdapter1** out_adapter)
1371 {
1372         try
1373         {
1374                 *out_adapter = new GalliumDXGIAdapter(factory, platform, dpy);
1375                 return S_OK;
1376         }
1377         catch(HRESULT hr)
1378         {
1379                 return hr;
1380         }
1381 }
1382
1383 static HRESULT GalliumDXGIOutputCreate(GalliumDXGIAdapter* adapter, const std::string& name, const struct native_connector* connector, IDXGIOutput** out_output)
1384 {
1385         try
1386         {
1387                 *out_output = new GalliumDXGIOutput(adapter, name, connector);
1388                 return S_OK;
1389         }
1390         catch(HRESULT hr)
1391         {
1392                 return hr;
1393         }
1394 }
1395
1396 static HRESULT GalliumDXGISwapChainCreate(GalliumDXGIFactory* factory, IUnknown* device, const DXGI_SWAP_CHAIN_DESC& desc, IDXGISwapChain** out_swap_chain)
1397 {
1398         try
1399         {
1400                 *out_swap_chain = new GalliumDXGISwapChain(factory, device, desc);
1401                 return S_OK;
1402         }
1403         catch(HRESULT hr)
1404         {
1405                 return hr;
1406         }
1407 }
1408
1409 struct dxgi_binding
1410 {
1411         const struct native_platform* platform;
1412         void* display;
1413         IGalliumDXGIBackend* backend;
1414 };
1415
1416 static dxgi_binding dxgi_default_binding;
1417 static __thread dxgi_binding dxgi_thread_binding;
1418 static const struct native_event_handler dxgi_event_handler = {
1419    GalliumDXGIAdapter::handle_invalid_surface,
1420    dxgi_loader_create_drm_screen,
1421    dxgi_loader_create_sw_screen
1422 };
1423
1424 void STDMETHODCALLTYPE GalliumDXGIUseNothing()
1425 {
1426         dxgi_thread_binding.platform = 0;
1427         dxgi_thread_binding.display = 0;
1428         if(dxgi_thread_binding.backend)
1429                 dxgi_thread_binding.backend->Release();
1430         dxgi_thread_binding.backend = 0;
1431 }
1432
1433 #ifdef GALLIUM_DXGI_USE_X11
1434 void STDMETHODCALLTYPE GalliumDXGIUseX11Display(Display* dpy, IGalliumDXGIBackend* backend)
1435 {
1436         GalliumDXGIUseNothing();
1437         dxgi_thread_binding.platform = native_get_x11_platform(&dxgi_event_handler);
1438         dxgi_thread_binding.display = dpy;
1439
1440         if(backend)
1441         {
1442                 dxgi_thread_binding.backend = backend;
1443                 backend->AddRef();
1444         }
1445 }
1446 #endif
1447
1448 /*
1449 #ifdef GALLIUM_DXGI_USE_DRM
1450 void STDMETHODCALLTYPE GalliumDXGIUseDRMCard(int fd)
1451 {
1452         GalliumDXGIUseNothing();
1453         dxgi_thread_binding.platform = native_get_drm_platform(&dxgi_event_handler);
1454         dxgi_thread_binding.display = (void*)fd;
1455         dxgi_thread_binding.backend = 0;
1456 }
1457 #endif
1458
1459 #ifdef GALLIUM_DXGI_USE_FBDEV
1460 void STDMETHODCALLTYPE GalliumDXGIUseFBDev(int fd)
1461 {
1462         GalliumDXGIUseNothing();
1463         dxgi_thread_binding.platform = native_get_fbdev_platform(&dxgi_event_handler);
1464         dxgi_thread_binding.display = (void*)fd;
1465         dxgi_thread_binding.backend = 0;
1466 }
1467 #endif
1468
1469 #ifdef GALLIUM_DXGI_USE_GDI
1470 void STDMETHODCALLTYPE GalliumDXGIUseHDC(HDC hdc, PFNHWNDRESOLVER resolver, void* resolver_cookie)
1471 {
1472         GalliumDXGIUseNothing();
1473         dxgi_thread_binding.platform = native_get_gdi_platform(&dxgi_event_handler);
1474         dxgi_thread_binding.display = (void*)hdc;
1475         dxgi_thread_binding.backend = 0;
1476 }
1477 #endif
1478 */
1479 void STDMETHODCALLTYPE GalliumDXGIMakeDefault()
1480 {
1481         if(dxgi_default_binding.backend)
1482                 dxgi_default_binding.backend->Release();
1483         dxgi_default_binding = dxgi_thread_binding;
1484         if(dxgi_default_binding.backend)
1485                 dxgi_default_binding.backend->AddRef();
1486 }
1487
1488  /* TODO: why did Microsoft add this? should we do something different for DXGI 1.0 and 1.1?
1489  * Or perhaps what they actually mean is "only create a single factory in your application"?
1490  * TODO: should we use a singleton here, so we never have multiple DXGI objects for the same thing? */
1491  HRESULT STDMETHODCALLTYPE CreateDXGIFactory1(
1492                 REFIID riid,
1493                 void **out_factory
1494 )
1495  {
1496          GalliumDXGIFactory* factory;
1497          *out_factory = 0;
1498          if(dxgi_thread_binding.platform)
1499                  factory = new GalliumDXGIFactory(dxgi_thread_binding.platform, dxgi_thread_binding.display, dxgi_thread_binding.backend);
1500          else if(dxgi_default_binding.platform)
1501                  factory = new GalliumDXGIFactory(dxgi_default_binding.platform, dxgi_default_binding.display, dxgi_default_binding.backend);
1502          else
1503                  factory = new GalliumDXGIFactory(native_get_x11_platform(&dxgi_event_handler), NULL, NULL);
1504          HRESULT hres = factory->QueryInterface(riid, out_factory);
1505          factory->Release();
1506          return hres;
1507  }
1508
1509  HRESULT STDMETHODCALLTYPE CreateDXGIFactory(
1510                  REFIID riid,
1511                  void **out_factor
1512 )
1513  {
1514          return CreateDXGIFactory1(riid, out_factor);
1515  }