blob: 1bcc75d946f9b8d55e8df1639ac13f3779cf78a9 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "printing/emf_win.h"
#include <stdint.h>
#include <algorithm>
#include <memory>
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/numerics/safe_conversions.h"
#include "base/win/scoped_gdi_object.h"
#include "base/win/scoped_hdc.h"
#include "base/win/scoped_select_object.h"
#include "skia/ext/skia_utils_win.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/codec/jpeg_codec.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
namespace printing {
namespace {
int CALLBACK IsAlphaBlendUsedEnumProc(HDC,
HANDLETABLE*,
const ENHMETARECORD *record,
int,
LPARAM data) {
bool* result = reinterpret_cast<bool*>(data);
if (!result)
return 0;
switch (record->iType) {
case EMR_ALPHABLEND: {
*result = true;
return 0;
break;
}
}
return 1;
}
int CALLBACK RasterizeAlphaBlendProc(HDC metafile_dc,
HANDLETABLE* handle_table,
const ENHMETARECORD *record,
int num_objects,
LPARAM data) {
HDC bitmap_dc = *reinterpret_cast<HDC*>(data);
// Play this command to the bitmap DC.
::PlayEnhMetaFileRecord(bitmap_dc, handle_table, record, num_objects);
switch (record->iType) {
case EMR_ALPHABLEND: {
const EMRALPHABLEND* alpha_blend =
reinterpret_cast<const EMRALPHABLEND*>(record);
// Don't modify transformation here.
// Old implementation did reset transformations for DC to identity matrix.
// That was not correct and cause some bugs, like unexpected cropping.
// EMRALPHABLEND is rendered into bitmap and metafile contexts with
// current transformation. If we don't touch them here BitBlt will copy
// same areas.
::BitBlt(metafile_dc,
alpha_blend->xDest,
alpha_blend->yDest,
alpha_blend->cxDest,
alpha_blend->cyDest,
bitmap_dc,
alpha_blend->xDest,
alpha_blend->yDest,
SRCCOPY);
break;
}
case EMR_CREATEBRUSHINDIRECT:
case EMR_CREATECOLORSPACE:
case EMR_CREATECOLORSPACEW:
case EMR_CREATEDIBPATTERNBRUSHPT:
case EMR_CREATEMONOBRUSH:
case EMR_CREATEPALETTE:
case EMR_CREATEPEN:
case EMR_DELETECOLORSPACE:
case EMR_DELETEOBJECT:
case EMR_EXTCREATEFONTINDIRECTW:
// Play object creation command only once.
break;
default:
// Play this command to the metafile DC.
::PlayEnhMetaFileRecord(metafile_dc, handle_table, record, num_objects);
break;
}
return 1; // Continue enumeration
}
// Bitmapt for rasterization.
class RasterBitmap {
public:
explicit RasterBitmap(const gfx::Size& raster_size) : saved_object_(nullptr) {
context_.Set(::CreateCompatibleDC(nullptr));
if (!context_.IsValid()) {
NOTREACHED() << "Bitmap DC creation failed";
return;
}
::SetGraphicsMode(context_.Get(), GM_ADVANCED);
void* bits = nullptr;
gfx::Rect bitmap_rect(raster_size);
skia::CreateBitmapHeader(raster_size.width(), raster_size.height(),
&header_.bmiHeader);
bitmap_.reset(CreateDIBSection(context_.Get(), &header_, DIB_RGB_COLORS,
&bits, nullptr, 0));
if (!bitmap_.is_valid())
NOTREACHED() << "Raster bitmap creation for printing failed";
saved_object_ = ::SelectObject(context_.Get(), bitmap_.get());
RECT rect = bitmap_rect.ToRECT();
::FillRect(context_.Get(), &rect,
static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
}
~RasterBitmap() {
::SelectObject(context_.Get(), saved_object_);
}
HDC context() const {
return context_.Get();
}
base::win::ScopedCreateDC context_;
BITMAPINFO header_;
base::win::ScopedBitmap bitmap_;
HGDIOBJ saved_object_;
private:
DISALLOW_COPY_AND_ASSIGN(RasterBitmap);
};
bool DIBFormatNativelySupported(HDC dc, uint32_t escape, const BYTE* bits,
int size) {
BOOL supported = FALSE;
if (ExtEscape(dc, QUERYESCSUPPORT, sizeof(escape),
reinterpret_cast<LPCSTR>(&escape), 0, 0) > 0) {
ExtEscape(dc, escape, size, reinterpret_cast<LPCSTR>(bits),
sizeof(supported), reinterpret_cast<LPSTR>(&supported));
}
return !!supported;
}
} // namespace
Emf::Emf() : emf_(nullptr), hdc_(nullptr) {}
Emf::~Emf() {
Close();
}
void Emf::Close() {
DCHECK(!hdc_);
if (emf_)
DeleteEnhMetaFile(emf_);
emf_ = nullptr;
}
bool Emf::InitToFile(const base::FilePath& metafile_path) {
DCHECK(!emf_ && !hdc_);
hdc_ = CreateEnhMetaFile(nullptr, metafile_path.value().c_str(), nullptr,
nullptr);
DCHECK(hdc_);
return !!hdc_;
}
bool Emf::InitFromFile(const base::FilePath& metafile_path) {
DCHECK(!emf_ && !hdc_);
emf_ = GetEnhMetaFile(metafile_path.value().c_str());
DCHECK(emf_);
return !!emf_;
}
bool Emf::Init() {
DCHECK(!emf_ && !hdc_);
hdc_ = CreateEnhMetaFile(nullptr, nullptr, nullptr, nullptr);
DCHECK(hdc_);
return !!hdc_;
}
bool Emf::InitFromData(const void* src_buffer, size_t src_buffer_size) {
DCHECK(!emf_ && !hdc_);
if (!base::IsValueInRangeForNumericType<UINT>(src_buffer_size))
return false;
emf_ = SetEnhMetaFileBits(static_cast<UINT>(src_buffer_size),
reinterpret_cast<const BYTE*>(src_buffer));
return !!emf_;
}
bool Emf::FinishDocument() {
DCHECK(!emf_ && hdc_);
emf_ = CloseEnhMetaFile(hdc_);
DCHECK(emf_);
hdc_ = nullptr;
return !!emf_;
}
bool Emf::Playback(HDC hdc, const RECT* rect) const {
DCHECK(emf_ && !hdc_);
RECT bounds;
if (!rect) {
// Get the natural bounds of the EMF buffer.
bounds = GetPageBounds(1).ToRECT();
rect = &bounds;
}
return PlayEnhMetaFile(hdc, emf_, rect) != 0;
}
bool Emf::SafePlayback(HDC context) const {
DCHECK(emf_ && !hdc_);
XFORM base_matrix;
if (!GetWorldTransform(context, &base_matrix)) {
NOTREACHED();
return false;
}
Emf::EnumerationContext playback_context;
playback_context.base_matrix = &base_matrix;
gfx::Rect bound = GetPageBounds(1);
RECT rect = bound.ToRECT();
return bound.IsEmpty() ||
EnumEnhMetaFile(context,
emf_,
&Emf::SafePlaybackProc,
reinterpret_cast<void*>(&playback_context),
&rect) != 0;
}
gfx::Rect Emf::GetPageBounds(unsigned int page_number) const {
DCHECK(emf_ && !hdc_);
DCHECK_EQ(1U, page_number);
ENHMETAHEADER header;
if (GetEnhMetaFileHeader(emf_, sizeof(header), &header) != sizeof(header)) {
NOTREACHED();
return gfx::Rect();
}
// Add 1 to right and bottom because it's inclusive rectangle.
// See ENHMETAHEADER.
return gfx::Rect(header.rclBounds.left,
header.rclBounds.top,
header.rclBounds.right - header.rclBounds.left + 1,
header.rclBounds.bottom - header.rclBounds.top + 1);
}
unsigned int Emf::GetPageCount() const {
return 1;
}
HDC Emf::context() const {
return hdc_;
}
uint32_t Emf::GetDataSize() const {
DCHECK(emf_ && !hdc_);
return GetEnhMetaFileBits(emf_, 0, nullptr);
}
bool Emf::GetData(void* buffer, uint32_t size) const {
DCHECK(emf_ && !hdc_);
DCHECK(buffer && size);
uint32_t size2 =
GetEnhMetaFileBits(emf_, size, reinterpret_cast<BYTE*>(buffer));
DCHECK(size2 == size);
return size2 == size && size2 != 0;
}
int CALLBACK Emf::SafePlaybackProc(HDC hdc,
HANDLETABLE* handle_table,
const ENHMETARECORD* record,
int objects_count,
LPARAM param) {
Emf::EnumerationContext* context =
reinterpret_cast<Emf::EnumerationContext*>(param);
context->handle_table = handle_table;
context->objects_count = objects_count;
context->hdc = hdc;
Record record_instance(record);
bool success = record_instance.SafePlayback(context);
DCHECK(success);
return 1;
}
Emf::EnumerationContext::EnumerationContext() {
memset(this, 0, sizeof(*this));
}
Emf::Record::Record(const ENHMETARECORD* record)
: record_(record) {
DCHECK(record_);
}
bool Emf::Record::Play(Emf::EnumerationContext* context) const {
return 0 != PlayEnhMetaFileRecord(context->hdc,
context->handle_table,
record_,
context->objects_count);
}
bool Emf::Record::SafePlayback(Emf::EnumerationContext* context) const {
// For EMF field description, see [MS-EMF] Enhanced Metafile Format
// Specification.
//
// This is the second major EMF breakage I get; the first one being
// SetDCBrushColor/SetDCPenColor/DC_PEN/DC_BRUSH being silently ignored.
//
// This function is the guts of the fix for bug 1186598. Some printer drivers
// somehow choke on certain EMF records, but calling the corresponding
// function directly on the printer HDC is fine. Still, playing the EMF record
// fails. Go figure.
//
// The main issue is that SetLayout is totally unsupported on these printers
// (HP 4500/4700). I used to call SetLayout and I stopped. I found out this is
// not sufficient because GDI32!PlayEnhMetaFile internally calls SetLayout(!)
// Damn.
//
// So I resorted to manually parse the EMF records and play them one by one.
// The issue with this method compared to using PlayEnhMetaFile to play back
// an EMF buffer is that the later silently fixes the matrix to take in
// account the matrix currently loaded at the time of the call.
// The matrix magic is done transparently when using PlayEnhMetaFile but since
// I'm processing one field at a time, I need to do the fixup myself. Note
// that PlayEnhMetaFileRecord doesn't fix the matrix correctly even when
// called inside an EnumEnhMetaFile loop. Go figure (bis).
//
// So when I see a EMR_SETWORLDTRANSFORM and EMR_MODIFYWORLDTRANSFORM, I need
// to fix the matrix according to the matrix previously loaded before playing
// back the buffer. Otherwise, the previously loaded matrix would be ignored
// and the EMF buffer would always be played back at its native resolution.
// Duh.
//
// I also use this opportunity to skip over eventual EMR_SETLAYOUT record that
// could remain.
//
// Another tweak we make is for JPEGs/PNGs in calls to StretchDIBits.
// (Our Pepper plugin code uses a JPEG). If the printer does not support
// JPEGs/PNGs natively we decompress the JPEG/PNG and then set it to the
// device.
// TODO(sanjeevr): We should also add JPEG/PNG support for SetSIBitsToDevice
//
// We also process any custom EMR_GDICOMMENT records which are our
// placeholders for StartPage and EndPage.
// Note: I should probably care about view ports and clipping, eventually.
bool res = false;
const XFORM* base_matrix = context->base_matrix;
switch (record()->iType) {
case EMR_STRETCHDIBITS: {
const EMRSTRETCHDIBITS* sdib_record =
reinterpret_cast<const EMRSTRETCHDIBITS*>(record());
const BYTE* record_start = reinterpret_cast<const BYTE *>(record());
const BITMAPINFOHEADER* bmih = reinterpret_cast<const BITMAPINFOHEADER*>(
record_start + sdib_record->offBmiSrc);
const BYTE* bits = record_start + sdib_record->offBitsSrc;
bool play_normally = true;
res = false;
HDC hdc = context->hdc;
std::unique_ptr<SkBitmap> bitmap;
if (bmih->biCompression == BI_JPEG) {
if (!DIBFormatNativelySupported(hdc, CHECKJPEGFORMAT, bits,
bmih->biSizeImage)) {
play_normally = false;
bitmap = gfx::JPEGCodec::Decode(bits, bmih->biSizeImage);
}
} else if (bmih->biCompression == BI_PNG) {
if (!DIBFormatNativelySupported(hdc, CHECKPNGFORMAT, bits,
bmih->biSizeImage)) {
play_normally = false;
bitmap = base::MakeUnique<SkBitmap>();
gfx::PNGCodec::Decode(bits, bmih->biSizeImage, bitmap.get());
}
}
if (play_normally) {
res = Play(context);
} else {
DCHECK(bitmap.get());
if (bitmap.get()) {
SkAutoLockPixels lock(*bitmap.get());
DCHECK_EQ(bitmap->colorType(), kN32_SkColorType);
const uint32_t* pixels =
static_cast<const uint32_t*>(bitmap->getPixels());
if (!pixels) {
NOTREACHED();
return false;
}
BITMAPINFOHEADER bmi = {0};
skia::CreateBitmapHeader(bitmap->width(), bitmap->height(), &bmi);
res = (0 != StretchDIBits(hdc, sdib_record->xDest, sdib_record->yDest,
sdib_record->cxDest,
sdib_record->cyDest, sdib_record->xSrc,
sdib_record->ySrc,
sdib_record->cxSrc, sdib_record->cySrc,
pixels,
reinterpret_cast<const BITMAPINFO *>(&bmi),
sdib_record->iUsageSrc,
sdib_record->dwRop));
}
}
break;
}
case EMR_SETWORLDTRANSFORM: {
DCHECK_EQ(record()->nSize, sizeof(DWORD) * 2 + sizeof(XFORM));
const XFORM* xform = reinterpret_cast<const XFORM*>(record()->dParm);
HDC hdc = context->hdc;
if (base_matrix) {
res = 0 != SetWorldTransform(hdc, base_matrix) &&
ModifyWorldTransform(hdc, xform, MWT_LEFTMULTIPLY);
} else {
res = 0 != SetWorldTransform(hdc, xform);
}
break;
}
case EMR_MODIFYWORLDTRANSFORM: {
DCHECK_EQ(record()->nSize,
sizeof(DWORD) * 2 + sizeof(XFORM) + sizeof(DWORD));
const XFORM* xform = reinterpret_cast<const XFORM*>(record()->dParm);
const DWORD* option = reinterpret_cast<const DWORD*>(xform + 1);
HDC hdc = context->hdc;
switch (*option) {
case MWT_IDENTITY:
if (base_matrix) {
res = 0 != SetWorldTransform(hdc, base_matrix);
} else {
res = 0 != ModifyWorldTransform(hdc, xform, MWT_IDENTITY);
}
break;
case MWT_LEFTMULTIPLY:
case MWT_RIGHTMULTIPLY:
res = 0 != ModifyWorldTransform(hdc, xform, *option);
break;
case 4: // MWT_SET
if (base_matrix) {
res = 0 != SetWorldTransform(hdc, base_matrix) &&
ModifyWorldTransform(hdc, xform, MWT_LEFTMULTIPLY);
} else {
res = 0 != SetWorldTransform(hdc, xform);
}
break;
default:
res = false;
break;
}
break;
}
case EMR_SETLAYOUT:
// Ignore it.
res = true;
break;
default: {
res = Play(context);
break;
}
}
return res;
}
void Emf::StartPage(const gfx::Size& /*page_size*/,
const gfx::Rect& /*content_area*/,
const float& /*scale_factor*/) {
}
bool Emf::FinishPage() {
return true;
}
Emf::Enumerator::Enumerator(const Emf& emf, HDC context, const RECT* rect) {
items_.clear();
if (!EnumEnhMetaFile(context,
emf.emf(),
&Emf::Enumerator::EnhMetaFileProc,
reinterpret_cast<void*>(this),
rect)) {
NOTREACHED();
items_.clear();
}
DCHECK_EQ(context_.hdc, context);
}
Emf::Enumerator::~Enumerator() {
}
Emf::Enumerator::const_iterator Emf::Enumerator::begin() const {
return items_.begin();
}
Emf::Enumerator::const_iterator Emf::Enumerator::end() const {
return items_.end();
}
int CALLBACK Emf::Enumerator::EnhMetaFileProc(HDC hdc,
HANDLETABLE* handle_table,
const ENHMETARECORD* record,
int objects_count,
LPARAM param) {
Enumerator& emf = *reinterpret_cast<Enumerator*>(param);
if (!emf.context_.handle_table) {
DCHECK(!emf.context_.handle_table);
DCHECK(!emf.context_.objects_count);
emf.context_.handle_table = handle_table;
emf.context_.objects_count = objects_count;
emf.context_.hdc = hdc;
} else {
DCHECK_EQ(emf.context_.handle_table, handle_table);
DCHECK_EQ(emf.context_.objects_count, objects_count);
DCHECK_EQ(emf.context_.hdc, hdc);
}
emf.items_.push_back(Record(record));
return 1;
}
bool Emf::IsAlphaBlendUsed() const {
bool result = false;
::EnumEnhMetaFile(nullptr, emf(), &IsAlphaBlendUsedEnumProc, &result,
nullptr);
return result;
}
std::unique_ptr<Emf> Emf::RasterizeMetafile(int raster_area_in_pixels) const {
gfx::Rect page_bounds = GetPageBounds(1);
gfx::Size page_size(page_bounds.size());
if (page_size.GetArea() <= 0) {
NOTREACHED() << "Metafile is empty";
page_bounds = gfx::Rect(1, 1);
}
float scale = sqrt(
static_cast<float>(raster_area_in_pixels) / page_size.GetArea());
page_size.set_width(std::max<int>(1, page_size.width() * scale));
page_size.set_height(std::max<int>(1, page_size.height() * scale));
RasterBitmap bitmap(page_size);
gfx::Rect bitmap_rect(page_size);
RECT rect = bitmap_rect.ToRECT();
Playback(bitmap.context(), &rect);
std::unique_ptr<Emf> result = base::MakeUnique<Emf>();
result->Init();
HDC hdc = result->context();
DCHECK(hdc);
skia::InitializeDC(hdc);
// Params are ignored.
result->StartPage(page_bounds.size(), page_bounds, 1);
::ModifyWorldTransform(hdc, nullptr, MWT_IDENTITY);
XFORM xform = {
static_cast<float>(page_bounds.width()) / bitmap_rect.width(),
0,
0,
static_cast<float>(page_bounds.height()) / bitmap_rect.height(),
static_cast<float>(page_bounds.x()),
static_cast<float>(page_bounds.y()),
};
::SetWorldTransform(hdc, &xform);
::BitBlt(hdc, 0, 0, bitmap_rect.width(), bitmap_rect.height(),
bitmap.context(), bitmap_rect.x(), bitmap_rect.y(), SRCCOPY);
result->FinishPage();
result->FinishDocument();
return result;
}
std::unique_ptr<Emf> Emf::RasterizeAlphaBlend() const {
gfx::Rect page_bounds = GetPageBounds(1);
if (page_bounds.size().GetArea() <= 0) {
NOTREACHED() << "Metafile is empty";
page_bounds = gfx::Rect(1, 1);
}
RasterBitmap bitmap(page_bounds.size());
// Map metafile page_bounds.x(), page_bounds.y() to bitmap 0, 0.
XFORM xform = {1,
0,
0,
1,
static_cast<float>(-page_bounds.x()),
static_cast<float>(-page_bounds.y())};
::SetWorldTransform(bitmap.context(), &xform);
std::unique_ptr<Emf> result = base::MakeUnique<Emf>();
result->Init();
HDC hdc = result->context();
DCHECK(hdc);
skia::InitializeDC(hdc);
HDC bitmap_dc = bitmap.context();
RECT rect = page_bounds.ToRECT();
::EnumEnhMetaFile(hdc, emf(), &RasterizeAlphaBlendProc, &bitmap_dc, &rect);
result->FinishDocument();
return result;
}
} // namespace printing