Home | History | Annotate | Download | only in metro_driver 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "stdafx.h"
      6 #include "win8/metro_driver/print_document_source.h"
      7 
      8 #include <windows.graphics.display.h>
      9 
     10 #include "base/logging.h"
     11 #include "base/numerics/safe_conversions.h"
     12 
     13 
     14 namespace {
     15 
     16 class D2DFactoryAutoLock {
     17  public:
     18   explicit D2DFactoryAutoLock(ID2D1Factory* d2d_factory) {
     19     HRESULT hr = d2d_factory->QueryInterface(IID_PPV_ARGS(&d2d_multithread_));
     20     if (d2d_multithread_.Get())
     21       d2d_multithread_->Enter();
     22     else
     23       NOTREACHED() << "Failed to QI for ID2D1Multithread " << std::hex << hr;
     24   }
     25 
     26   ~D2DFactoryAutoLock() {
     27     if (d2d_multithread_.Get())
     28       d2d_multithread_->Leave();
     29   }
     30 
     31  private:
     32   mswr::ComPtr<ID2D1Multithread> d2d_multithread_;
     33 };
     34 
     35 // TODO(mad): remove once we don't run mixed SDK/OS anymore.
     36 const GUID kOldPackageTargetGuid =
     37     {0xfb2a33c0, 0x8c35, 0x465f,
     38       {0xbe, 0xd5, 0x9f, 0x36, 0x89, 0x51, 0x77, 0x52}};
     39 const GUID kNewPackageTargetGuid =
     40     {0x1a6dd0ad, 0x1e2a, 0x4e99,
     41       {0xa5, 0xba, 0x91, 0xf1, 0x78, 0x18, 0x29, 0x0e}};
     42 
     43 
     44 }  // namespace
     45 
     46 namespace metro_driver {
     47 
     48 PrintDocumentSource::PrintDocumentSource()
     49     : page_count_ready_(true, false),
     50       parent_lock_(NULL),
     51       height_(0),
     52       width_(0),
     53       dpi_(96),
     54       aborted_(false),
     55       using_old_preview_interface_(false) {
     56 }
     57 
     58 HRESULT PrintDocumentSource::RuntimeClassInitialize(
     59     const DirectXContext& directx_context,
     60     base::Lock* parent_lock) {
     61   DCHECK(parent_lock != NULL);
     62   DCHECK(directx_context.d2d_context.Get() != NULL);
     63   DCHECK(directx_context.d2d_device.Get() != NULL);
     64   DCHECK(directx_context.d2d_factory.Get() != NULL);
     65   DCHECK(directx_context.d3d_device.Get() != NULL);
     66   DCHECK(directx_context.wic_factory.Get() != NULL);
     67   directx_context_ = directx_context;
     68 
     69   // No other method can be called before RuntimeClassInitialize which is called
     70   // during the construction via mswr::MakeAndInitialize(), so it's safe for all
     71   // other methods to use the parent_lock_ without checking if it's NULL.
     72   DCHECK(parent_lock_ == NULL);
     73   parent_lock_ = parent_lock;
     74 
     75   return S_OK;
     76 }
     77 
     78 void PrintDocumentSource::Abort() {
     79   base::AutoLock lock(*parent_lock_);
     80   aborted_ = true;
     81   if (page_count_ready_.IsSignaled()) {
     82     pages_.clear();
     83     for (size_t i = 0; i < pages_ready_state_.size(); ++i)
     84       pages_ready_state_[i]->Broadcast();
     85   } else {
     86     DCHECK(pages_.empty() && pages_ready_state_.empty());
     87   }
     88 }
     89 
     90 STDMETHODIMP PrintDocumentSource::GetPreviewPageCollection(
     91     IPrintDocumentPackageTarget* package_target,
     92     IPrintPreviewPageCollection** page_collection) {
     93   DVLOG(1) << __FUNCTION__;
     94   DCHECK(package_target != NULL);
     95   DCHECK(page_collection != NULL);
     96 
     97   HRESULT hr = package_target->GetPackageTarget(
     98       __uuidof(IPrintPreviewDxgiPackageTarget),
     99       IID_PPV_ARGS(&dxgi_preview_target_));
    100   if (FAILED(hr)) {
    101     // TODO(mad): remove once we don't run mixed SDK/OS anymore.
    102     // The IID changed from one version of the SDK to another, so try the other
    103     // one in case we are running a build from a different SDK than the one
    104     // related to the OS version we are running.
    105     GUID package_target_uuid = kNewPackageTargetGuid;
    106     if (package_target_uuid == __uuidof(IPrintPreviewDxgiPackageTarget)) {
    107       package_target_uuid = kOldPackageTargetGuid;
    108       using_old_preview_interface_ = true;
    109     }
    110     hr = package_target->GetPackageTarget(package_target_uuid,
    111                                           package_target_uuid,
    112                                           &dxgi_preview_target_);
    113     if (FAILED(hr)) {
    114       LOG(ERROR) << "Failed to get IPrintPreviewDXGIPackageTarget " << std::hex
    115                  << hr;
    116       return hr;
    117     }
    118   } else {
    119     using_old_preview_interface_ = (__uuidof(IPrintPreviewDxgiPackageTarget) ==
    120                                     kOldPackageTargetGuid);
    121   }
    122 
    123   mswr::ComPtr<IPrintPreviewPageCollection> preview_page_collection;
    124   mswr::ComPtr<PrintDocumentSource> print_document_source(this);
    125   hr = print_document_source.As(&preview_page_collection);
    126   if (FAILED(hr)) {
    127     LOG(ERROR) << "Failed to get preview_page_collection " << std::hex << hr;
    128     return hr;
    129   }
    130 
    131   hr = preview_page_collection.CopyTo(page_collection);
    132   if (FAILED(hr)) {
    133     LOG(ERROR) << "Failed to copy preview_page_collection " << std::hex << hr;
    134     return hr;
    135   }
    136   return hr;
    137 }
    138 
    139 STDMETHODIMP PrintDocumentSource::MakeDocument(
    140     IInspectable* options,
    141     IPrintDocumentPackageTarget* package_target) {
    142   DVLOG(1) << __FUNCTION__;
    143   DCHECK(options != NULL);
    144   DCHECK(package_target != NULL);
    145 
    146   mswr::ComPtr<wingfx::Printing::IPrintTaskOptionsCore> print_task_options;
    147   HRESULT hr = options->QueryInterface(
    148       wingfx::Printing::IID_IPrintTaskOptionsCore,
    149       reinterpret_cast<void**>(print_task_options.GetAddressOf()));
    150   if (FAILED(hr)) {
    151     LOG(ERROR) << "Failed to QI for IPrintTaskOptionsCore " << std::hex << hr;
    152     return hr;
    153   }
    154 
    155   // Use the first page's description for the whole document. Page numbers
    156   // are 1-based in this context.
    157   // TODO(mad): Check if it would be useful to use per page descriptions.
    158   wingfx::Printing::PrintPageDescription page_desc = {};
    159   hr = print_task_options->GetPageDescription(1 /* page */, &page_desc);
    160   if (FAILED(hr)) {
    161     LOG(ERROR) << "Failed to GetPageDescription " << std::hex << hr;
    162     return hr;
    163   }
    164 
    165   D2D1_PRINT_CONTROL_PROPERTIES print_control_properties;
    166   if (page_desc.DpiX > page_desc.DpiY)
    167     print_control_properties.rasterDPI = static_cast<float>(page_desc.DpiY);
    168   else
    169     print_control_properties.rasterDPI = static_cast<float>(page_desc.DpiX);
    170 
    171   // Color space for vector graphics in D2D print control.
    172   print_control_properties.colorSpace = D2D1_COLOR_SPACE_SRGB;
    173   print_control_properties.fontSubset = D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT;
    174 
    175   mswr::ComPtr<ID2D1PrintControl> print_control;
    176   hr = directx_context_.d2d_device->CreatePrintControl(
    177       directx_context_.wic_factory.Get(),
    178       package_target,
    179       print_control_properties,
    180       print_control.GetAddressOf());
    181   if (FAILED(hr)) {
    182     LOG(ERROR) << "Failed to CreatePrintControl " << std::hex << hr;
    183     return hr;
    184   }
    185 
    186   D2D1_SIZE_F page_size = D2D1::SizeF(page_desc.PageSize.Width,
    187                                       page_desc.PageSize.Height);
    188 
    189   // Wait for the number of pages to be available.
    190   // If an abort occured, we'll get 0 and won't enter the loop below.
    191   size_t page_count = WaitAndGetPageCount();
    192 
    193   mswr::ComPtr<ID2D1GdiMetafile> gdi_metafile;
    194   for (size_t page = 0; page < page_count; ++page) {
    195     gdi_metafile.Reset();
    196     hr = WaitAndGetPage(page, gdi_metafile.GetAddressOf());
    197     LOG_IF(ERROR, FAILED(hr)) << "Failed to get page's metafile " << std::hex
    198                               << hr;
    199     // S_FALSE means we got aborted.
    200     if (hr == S_FALSE || FAILED(hr))
    201       break;
    202     hr = PrintPage(print_control.Get(), gdi_metafile.Get(), page_size);
    203     if (FAILED(hr))
    204       break;
    205   }
    206 
    207   HRESULT close_hr = print_control->Close();
    208   if (FAILED(close_hr) && SUCCEEDED(hr))
    209     return close_hr;
    210   else
    211     return hr;
    212 }
    213 
    214 STDMETHODIMP PrintDocumentSource::Paginate(uint32 page,
    215                                            IInspectable* options) {
    216   DVLOG(1) << __FUNCTION__ << ", page = " << page;
    217   DCHECK(options != NULL);
    218   // GetPreviewPageCollection must have been successfuly called.
    219   DCHECK(dxgi_preview_target_.Get() != NULL);
    220 
    221   // Get print settings from PrintTaskOptions for preview, such as page
    222   // description, which contains page size, imageable area, DPI.
    223   // TODO(mad): obtain other print settings in the same way, such as ColorMode,
    224   // NumberOfCopies, etc...
    225   mswr::ComPtr<wingfx::Printing::IPrintTaskOptionsCore> print_options;
    226   HRESULT hr = options->QueryInterface(
    227       wingfx::Printing::IID_IPrintTaskOptionsCore,
    228       reinterpret_cast<void**>(print_options.GetAddressOf()));
    229   if (FAILED(hr)) {
    230     LOG(ERROR) << "Failed to QI for IPrintTaskOptionsCore " << std::hex << hr;
    231     return hr;
    232   }
    233 
    234   wingfx::Printing::PrintPageDescription page_desc = {};
    235   hr = print_options->GetPageDescription(1 /* page */, &page_desc);
    236   if (FAILED(hr)) {
    237     LOG(ERROR) << "Failed to GetPageDescription " << std::hex << hr;
    238     return hr;
    239   }
    240 
    241   width_ = page_desc.PageSize.Width;
    242   height_ = page_desc.PageSize.Height;
    243 
    244   hr = dxgi_preview_target_->InvalidatePreview();
    245   if (FAILED(hr)) {
    246     LOG(ERROR) << "Failed to InvalidatePreview " << std::hex << hr;
    247     return hr;
    248   }
    249 
    250   size_t page_count = WaitAndGetPageCount();
    251   // A page_count of 0 means abort...
    252   if (page_count == 0)
    253     return S_FALSE;
    254   hr = dxgi_preview_target_->SetJobPageCount(
    255            PageCountType::FinalPageCount,
    256            base::checked_cast<UINT32>(page_count));
    257   if (FAILED(hr)) {
    258     LOG(ERROR) << "Failed to SetJobPageCount " << std::hex << hr;
    259     return hr;
    260   }
    261   return hr;
    262 }
    263 
    264 STDMETHODIMP PrintDocumentSource::MakePage(uint32 job_page,
    265                                            float width,
    266                                            float height) {
    267   DVLOG(1) << __FUNCTION__ << ", width: " << width << ", height: " << height
    268           << ", job_page: " << job_page;
    269   DCHECK(width > 0 && height > 0);
    270   // Paginate must have been called before this.
    271   if (width_ <= 0.0 || height_ <= 0.0)
    272     return S_FALSE;
    273 
    274   // When job_page is JOB_PAGE_APPLICATION_DEFINED, it means a new preview
    275   // begins. TODO(mad): Double check if we need to cancel pending resources.
    276   if (job_page == JOB_PAGE_APPLICATION_DEFINED)
    277     job_page = 1;
    278 
    279   winfoundtn::Size preview_size;
    280   preview_size.Width  = width;
    281   preview_size.Height = height;
    282   float scale = width_ / width;
    283 
    284   mswr::ComPtr<ID2D1Factory> factory;
    285   directx_context_.d2d_device->GetFactory(&factory);
    286 
    287   mswr::ComPtr<ID2D1GdiMetafile> gdi_metafile;
    288   HRESULT hr = WaitAndGetPage(job_page - 1, gdi_metafile.GetAddressOf());
    289   LOG_IF(ERROR, FAILED(hr)) << "Failed to get page's metafile " << std::hex
    290                             << hr;
    291   // Again, S_FALSE means we got aborted.
    292   if (hr == S_FALSE || FAILED(hr))
    293     return hr;
    294 
    295   // We are accessing D3D resources directly without D2D's knowledge, so we
    296   // must manually acquire the D2D factory lock.
    297   D2DFactoryAutoLock factory_lock(directx_context_.d2d_factory.Get());
    298 
    299   CD3D11_TEXTURE2D_DESC texture_desc(
    300       DXGI_FORMAT_B8G8R8A8_UNORM,
    301       static_cast<UINT32>(ceil(width  * dpi_ / 96)),
    302       static_cast<UINT32>(ceil(height * dpi_ / 96)),
    303       1,
    304       1,
    305       D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE
    306       );
    307   mswr::ComPtr<ID3D11Texture2D> texture;
    308   hr = directx_context_.d3d_device->CreateTexture2D(
    309       &texture_desc, NULL, &texture);
    310   if (FAILED(hr)) {
    311     LOG(ERROR) << "Failed to create a 2D texture " << std::hex << hr;
    312     return hr;
    313   }
    314 
    315   mswr::ComPtr<IDXGISurface> dxgi_surface;
    316   hr = texture.As<IDXGISurface>(&dxgi_surface);
    317   if (FAILED(hr)) {
    318     LOG(ERROR) << "Failed to QI for IDXGISurface " << std::hex << hr;
    319     return hr;
    320   }
    321 
    322   // D2D device contexts are stateful, and hence a unique device context must
    323   // be used on each call.
    324   mswr::ComPtr<ID2D1DeviceContext> d2d_context;
    325   hr = directx_context_.d2d_device->CreateDeviceContext(
    326       D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &d2d_context);
    327 
    328   d2d_context->SetDpi(dpi_, dpi_);
    329 
    330   mswr::ComPtr<ID2D1Bitmap1> d2dSurfaceBitmap;
    331   hr = d2d_context->CreateBitmapFromDxgiSurface(dxgi_surface.Get(),
    332                                                 NULL,  // default properties.
    333                                                 &d2dSurfaceBitmap);
    334   if (FAILED(hr)) {
    335     LOG(ERROR) << "Failed to CreateBitmapFromDxgiSurface " << std::hex << hr;
    336     return hr;
    337   }
    338 
    339   d2d_context->SetTarget(d2dSurfaceBitmap.Get());
    340   d2d_context->BeginDraw();
    341   d2d_context->Clear();
    342   d2d_context->SetTransform(D2D1::Matrix3x2F(1/scale, 0, 0, 1/scale, 0, 0));
    343   d2d_context->DrawGdiMetafile(gdi_metafile.Get());
    344 
    345   hr = d2d_context->EndDraw();
    346   if (FAILED(hr)) {
    347     LOG(ERROR) << "Failed to EndDraw " << std::hex << hr;
    348     return hr;
    349   }
    350 
    351 // TODO(mad): remove once we don't run mixed SDK/OS anymore.
    352 #ifdef __IPrintPreviewDxgiPackageTarget_FWD_DEFINED__
    353   FLOAT dpi = dpi_;
    354   if (using_old_preview_interface_) {
    355     // We compiled with the new API but run on the old OS, so we must cheat
    356     // and send something that looks like a float but has a UINT32 value.
    357     *reinterpret_cast<UINT32*>(&dpi) = static_cast<UINT32>(dpi_);
    358   }
    359 #else
    360   UINT32 dpi = static_cast<UINT32>(dpi_);
    361   if (!using_old_preview_interface_) {
    362     // We compiled with the old API but run on the new OS, so we must cheat
    363     // and send something that looks like a UINT32 but has a float value.
    364     *reinterpret_cast<FLOAT*>(&dpi) = dpi_;
    365   }
    366 #endif  // __IPrintPreviewDxgiPackageTarget_FWD_DEFINED__
    367   hr = dxgi_preview_target_->DrawPage(job_page, dxgi_surface.Get(), dpi, dpi);
    368   if (FAILED(hr)) {
    369     LOG(ERROR) << "Failed to DrawPage " << std::hex << hr;
    370     return hr;
    371   }
    372   return hr;
    373 }
    374 
    375 void PrintDocumentSource::ResetDpi(float dpi) {
    376   {
    377     base::AutoLock lock(*parent_lock_);
    378     if (dpi == dpi_)
    379       return;
    380     dpi_ = dpi;
    381   }
    382   directx_context_.d2d_context->SetDpi(dpi, dpi);
    383 }
    384 
    385 void PrintDocumentSource::SetPageCount(size_t page_count) {
    386   DCHECK(page_count > 0);
    387   {
    388     base::AutoLock lock(*parent_lock_);
    389     DCHECK(!page_count_ready_.IsSignaled());
    390     DCHECK(pages_.empty() && pages_ready_state_.empty());
    391 
    392     pages_.resize(page_count);
    393     pages_ready_state_.resize(page_count);
    394 
    395     for (size_t i = 0; i < page_count; ++i)
    396       pages_ready_state_[i].reset(new base::ConditionVariable(parent_lock_));
    397   }
    398   page_count_ready_.Signal();
    399 }
    400 
    401 void PrintDocumentSource::AddPage(size_t page_number,
    402                                   IStream* metafile_stream) {
    403   DCHECK(metafile_stream != NULL);
    404   base::AutoLock lock(*parent_lock_);
    405 
    406   DCHECK(page_count_ready_.IsSignaled());
    407   DCHECK(page_number < pages_.size());
    408 
    409   pages_[page_number] = metafile_stream;
    410   pages_ready_state_[page_number]->Signal();
    411 }
    412 
    413 HRESULT PrintDocumentSource::PrintPage(ID2D1PrintControl* print_control,
    414                                        ID2D1GdiMetafile* gdi_metafile,
    415                                        D2D1_SIZE_F page_size) {
    416   DVLOG(1) << __FUNCTION__ << ", page_size: (" << page_size.width << ", "
    417           << page_size.height << ")";
    418   DCHECK(print_control != NULL);
    419   DCHECK(gdi_metafile != NULL);
    420 
    421   // D2D device contexts are stateful, and hence a unique device context must
    422   // be used on each call.
    423   mswr::ComPtr<ID2D1DeviceContext> d2d_context;
    424   HRESULT hr = directx_context_.d2d_device->CreateDeviceContext(
    425       D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &d2d_context);
    426   if (FAILED(hr)) {
    427     LOG(ERROR) << "Failed to CreateDeviceContext " << std::hex << hr;
    428     return hr;
    429   }
    430 
    431   mswr::ComPtr<ID2D1CommandList> print_command_list;
    432   hr = d2d_context->CreateCommandList(&print_command_list);
    433   if (FAILED(hr)) {
    434     LOG(ERROR) << "Failed to CreateCommandList " << std::hex << hr;
    435     return hr;
    436   }
    437 
    438   d2d_context->SetTarget(print_command_list.Get());
    439 
    440   d2d_context->BeginDraw();
    441   d2d_context->DrawGdiMetafile(gdi_metafile);
    442   hr = d2d_context->EndDraw();
    443   LOG_IF(ERROR, FAILED(hr)) << "Failed to EndDraw " << std::hex << hr;
    444 
    445   // Make sure to always close the command list.
    446   HRESULT close_hr = print_command_list->Close();
    447   LOG_IF(ERROR, FAILED(close_hr)) << "Failed to close command list " << std::hex
    448                                   << hr;
    449   if (SUCCEEDED(hr) && SUCCEEDED(close_hr))
    450     hr = print_control->AddPage(print_command_list.Get(), page_size, NULL);
    451   if (FAILED(hr))
    452     return hr;
    453   else
    454     return close_hr;
    455 }
    456 
    457 size_t PrintDocumentSource::WaitAndGetPageCount() {
    458   // Properly protect the wait/access to the page count.
    459   {
    460     base::AutoLock lock(*parent_lock_);
    461     if (aborted_)
    462       return 0;
    463     DCHECK(pages_.size() == pages_ready_state_.size());
    464     if (!pages_.empty())
    465       return pages_.size();
    466   }
    467   page_count_ready_.Wait();
    468   {
    469     base::AutoLock lock(*parent_lock_);
    470     if (!aborted_) {
    471       DCHECK(pages_.size() == pages_ready_state_.size());
    472       return pages_.size();
    473     }
    474   }
    475   // A page count of 0 means abort.
    476   return 0;
    477 }
    478 
    479 HRESULT PrintDocumentSource::WaitAndGetPage(size_t page_number,
    480                                             ID2D1GdiMetafile** gdi_metafile) {
    481   // Properly protect the wait/access to the page data.
    482   base::AutoLock lock(*parent_lock_);
    483   // Make sure we weren't canceled before getting here.
    484   // And the page count should have been received before we get here too.
    485   if (aborted_)
    486     return S_FALSE;
    487 
    488   // We shouldn't be asked for a page until we got the page count.
    489   DCHECK(page_count_ready_.IsSignaled());
    490   DCHECK(page_number <= pages_ready_state_.size());
    491   DCHECK(pages_.size() == pages_ready_state_.size());
    492   while (!aborted_ && pages_[page_number].Get() == NULL)
    493     pages_ready_state_[page_number]->Wait();
    494 
    495   // Make sure we weren't aborted while we waited unlocked.
    496   if (aborted_)
    497     return S_FALSE;
    498   DCHECK(page_number < pages_.size());
    499 
    500   mswr::ComPtr<ID2D1Factory> factory;
    501   directx_context_.d2d_device->GetFactory(&factory);
    502 
    503   mswr::ComPtr<ID2D1Factory1> factory1;
    504   HRESULT hr = factory.As(&factory1);
    505   if (FAILED(hr)) {
    506     LOG(ERROR) << "Failed to QI for ID2D1Factory1 " << std::hex << hr;
    507     return hr;
    508   }
    509 
    510   ULARGE_INTEGER result;
    511   LARGE_INTEGER seek_pos;
    512   seek_pos.QuadPart = 0;
    513   hr = pages_[page_number]->Seek(seek_pos, STREAM_SEEK_SET, &result);
    514   if (FAILED(hr)) {
    515     LOG(ERROR) << "Failed to Seek page stream " << std::hex << hr;
    516     return hr;
    517   }
    518 
    519   hr = factory1->CreateGdiMetafile(pages_[page_number].Get(), gdi_metafile);
    520   if (FAILED(hr)) {
    521     LOG(ERROR) << "Failed to CreateGdiMetafile " << std::hex << hr;
    522     return hr;
    523   }
    524   return hr;
    525 }
    526 
    527 }  // namespace metro_driver
    528