1 // Copyright 2013 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 "chrome/utility/cloud_print/pwg_encoder.h" 6 7 #include <algorithm> 8 9 #include "base/big_endian.h" 10 #include "base/logging.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "chrome/utility/cloud_print/bitmap_image.h" 13 14 namespace cloud_print { 15 16 namespace { 17 18 const uint32 kBitsPerColor = 8; 19 const uint32 kColorOrder = 0; // chunky. 20 21 // Coefficients used to convert from RGB to monochrome. 22 const uint32 kRedCoefficient = 2125; 23 const uint32 kGreenCoefficient = 7154; 24 const uint32 kBlueCoefficient = 0721; 25 const uint32 kColorCoefficientDenominator = 10000; 26 27 const char* kPwgKeyword = "RaS2"; 28 29 const uint32 kHeaderSize = 1796; 30 const uint32 kHeaderCupsDuplex = 272; 31 const uint32 kHeaderCupsHwResolutionHorizontal = 276; 32 const uint32 kHeaderCupsHwResolutionVertical = 280; 33 const uint32 kHeaderCupsTumble = 368; 34 const uint32 kHeaderCupsWidth = 372; 35 const uint32 kHeaderCupsHeight = 376; 36 const uint32 kHeaderCupsBitsPerColor = 384; 37 const uint32 kHeaderCupsBitsPerPixel = 388; 38 const uint32 kHeaderCupsBytesPerLine = 392; 39 const uint32 kHeaderCupsColorOrder = 396; 40 const uint32 kHeaderCupsColorSpace = 400; 41 const uint32 kHeaderCupsNumColors = 420; 42 const uint32 kHeaderPwgTotalPageCount = 452; 43 const uint32 kHeaderPwgCrossFeedTransform = 456; 44 const uint32 kHeaderPwgFeedTransform = 460; 45 46 const int kPwgMaxPackedRows = 256; 47 48 const int kPwgMaxPackedPixels = 128; 49 50 struct RGBA8 { 51 uint8 red; 52 uint8 green; 53 uint8 blue; 54 uint8 alpha; 55 }; 56 57 struct BGRA8 { 58 uint8 blue; 59 uint8 green; 60 uint8 red; 61 uint8 alpha; 62 }; 63 64 template <class InputStruct> 65 inline void encodePixelToRGB(const void* pixel, std::string* output) { 66 const InputStruct* i = reinterpret_cast<const InputStruct*>(pixel); 67 output->push_back(static_cast<char>(i->red)); 68 output->push_back(static_cast<char>(i->green)); 69 output->push_back(static_cast<char>(i->blue)); 70 } 71 72 template <class InputStruct> 73 inline void encodePixelToMonochrome(const void* pixel, std::string* output) { 74 const InputStruct* i = reinterpret_cast<const InputStruct*>(pixel); 75 output->push_back(static_cast<char>((i->red * kRedCoefficient + 76 i->green * kGreenCoefficient + 77 i->blue * kBlueCoefficient) / 78 kColorCoefficientDenominator)); 79 } 80 81 } // namespace 82 83 PwgEncoder::PwgEncoder() {} 84 85 void PwgEncoder::EncodeDocumentHeader(std::string* output) const { 86 output->clear(); 87 output->append(kPwgKeyword, 4); 88 } 89 90 void PwgEncoder::EncodePageHeader(const BitmapImage& image, 91 const PwgHeaderInfo& pwg_header_info, 92 std::string* output) const { 93 char header[kHeaderSize]; 94 memset(header, 0, kHeaderSize); 95 96 uint32 num_colors = 97 pwg_header_info.color_space == PwgHeaderInfo::SGRAY ? 1 : 3; 98 uint32 bits_per_pixel = num_colors * kBitsPerColor; 99 100 base::WriteBigEndian<uint32>(header + kHeaderCupsDuplex, 101 pwg_header_info.duplex ? 1 : 0); 102 base::WriteBigEndian<uint32>(header + kHeaderCupsHwResolutionHorizontal, 103 pwg_header_info.dpi); 104 base::WriteBigEndian<uint32>(header + kHeaderCupsHwResolutionVertical, 105 pwg_header_info.dpi); 106 base::WriteBigEndian<uint32>(header + kHeaderCupsTumble, 107 pwg_header_info.tumble ? 1 : 0); 108 base::WriteBigEndian<uint32>(header + kHeaderCupsWidth, image.size().width()); 109 base::WriteBigEndian<uint32>(header + kHeaderCupsHeight, 110 image.size().height()); 111 base::WriteBigEndian<uint32>(header + kHeaderCupsBitsPerColor, kBitsPerColor); 112 base::WriteBigEndian<uint32>(header + kHeaderCupsBitsPerPixel, 113 bits_per_pixel); 114 base::WriteBigEndian<uint32>(header + kHeaderCupsBytesPerLine, 115 (bits_per_pixel * image.size().width() + 7) / 8); 116 base::WriteBigEndian<uint32>(header + kHeaderCupsColorOrder, kColorOrder); 117 base::WriteBigEndian<uint32>(header + kHeaderCupsColorSpace, 118 pwg_header_info.color_space); 119 base::WriteBigEndian<uint32>(header + kHeaderCupsNumColors, num_colors); 120 base::WriteBigEndian<uint32>(header + kHeaderPwgCrossFeedTransform, 121 pwg_header_info.flipx ? -1 : 1); 122 base::WriteBigEndian<uint32>(header + kHeaderPwgFeedTransform, 123 pwg_header_info.flipy ? -1 : 1); 124 base::WriteBigEndian<uint32>(header + kHeaderPwgTotalPageCount, 125 pwg_header_info.total_pages); 126 output->append(header, kHeaderSize); 127 } 128 129 template <typename InputStruct, class RandomAccessIterator> 130 void PwgEncoder::EncodeRow(RandomAccessIterator pos, 131 RandomAccessIterator row_end, 132 bool monochrome, 133 std::string* output) const { 134 // According to PWG-raster, a sequence of N identical pixels (up to 128) 135 // can be encoded by a byte N-1, followed by the information on 136 // that pixel. Any generic sequence of N pixels (up to 129) can be encoded 137 // with (signed) byte 1-N, followed by the information on the N pixels. 138 // Notice that for sequences of 1 pixel there is no difference between 139 // the two encodings. 140 141 // We encode every largest sequence of identical pixels together because it 142 // usually saves the most space. Every other pixel should be encoded in the 143 // smallest number of generic sequences. 144 // NOTE: the algorithm is not optimal especially in case of monochrome. 145 while (pos != row_end) { 146 RandomAccessIterator it = pos + 1; 147 RandomAccessIterator end = std::min(pos + kPwgMaxPackedPixels, row_end); 148 149 // Counts how many identical pixels (up to 128). 150 while (it != end && *pos == *it) { 151 ++it; 152 } 153 if (it != pos + 1) { // More than one pixel 154 output->push_back(static_cast<char>((it - pos) - 1)); 155 if (monochrome) 156 encodePixelToMonochrome<InputStruct>(&*pos, output); 157 else 158 encodePixelToRGB<InputStruct>(&*pos, output); 159 pos = it; 160 } else { 161 // Finds how many pixels there are each different from the previous one. 162 // IMPORTANT: even if sequences of different pixels can contain as many 163 // as 129 pixels, we restrict to 128 because some decoders don't manage 164 // it correctly. So iterating until it != end is correct. 165 while (it != end && *it != *(it - 1)) { 166 ++it; 167 } 168 // Optimization: ignores the last pixel of the sequence if it is followed 169 // by an identical pixel, as it is more convenient for it to be the start 170 // of a new sequence of identical pixels. Notice that we don't compare 171 // to end, but row_end. 172 if (it != row_end && *it == *(it - 1)) { 173 --it; 174 } 175 output->push_back(static_cast<char>(1 - (it - pos))); 176 while (pos != it) { 177 if (monochrome) 178 encodePixelToMonochrome<InputStruct>(&*pos, output); 179 else 180 encodePixelToRGB<InputStruct>(&*pos, output); 181 ++pos; 182 } 183 } 184 } 185 } 186 187 inline const uint8* PwgEncoder::GetRow(const BitmapImage& image, 188 int row, 189 bool flipy) const { 190 return image.GetPixel( 191 gfx::Point(0, flipy ? image.size().height() - 1 - row : row)); 192 } 193 194 // Given a pointer to a struct Image, create a PWG of the image and 195 // put the compressed image data in the string. Returns true on success. 196 // The content of the string is undefined on failure. 197 bool PwgEncoder::EncodePage(const BitmapImage& image, 198 const PwgHeaderInfo& pwg_header_info, 199 std::string* output) const { 200 // pwg_header_info.color_space can only contain color spaces that are 201 // supported, so no sanity check is needed. 202 switch (image.colorspace()) { 203 case BitmapImage::RGBA: 204 return EncodePageWithColorspace<RGBA8>(image, pwg_header_info, output); 205 206 case BitmapImage::BGRA: 207 return EncodePageWithColorspace<BGRA8>(image, pwg_header_info, output); 208 209 default: 210 LOG(ERROR) << "Unsupported colorspace."; 211 return false; 212 } 213 } 214 215 template <typename InputStruct> 216 bool PwgEncoder::EncodePageWithColorspace(const BitmapImage& image, 217 const PwgHeaderInfo& pwg_header_info, 218 std::string* output) const { 219 bool monochrome = pwg_header_info.color_space == PwgHeaderInfo::SGRAY; 220 EncodePageHeader(image, pwg_header_info, output); 221 222 // Ensure no integer overflow. 223 CHECK(image.size().width() < INT_MAX / image.channels()); 224 int row_size = image.size().width() * image.channels(); 225 226 int row_number = 0; 227 while (row_number < image.size().height()) { 228 const uint8* current_row = 229 GetRow(image, row_number++, pwg_header_info.flipy); 230 int num_identical_rows = 1; 231 // We count how many times the current row is repeated. 232 while (num_identical_rows < kPwgMaxPackedRows && 233 row_number < image.size().height() && 234 !memcmp(current_row, 235 GetRow(image, row_number, pwg_header_info.flipy), 236 row_size)) { 237 num_identical_rows++; 238 row_number++; 239 } 240 output->push_back(static_cast<char>(num_identical_rows - 1)); 241 242 // Both supported colorspaces have a 32-bit pixels information. 243 // Converts the list of uint8 to uint32 as every pixels contains 4 bytes 244 // of information and comparison of elements is easier. The actual 245 // Management of the bytes of the pixel is done by pixel_encoder function 246 // on the original array to avoid endian problems. 247 const uint32* pos = reinterpret_cast<const uint32*>(current_row); 248 const uint32* row_end = pos + image.size().width(); 249 if (!pwg_header_info.flipx) { 250 EncodeRow<InputStruct>(pos, row_end, monochrome, output); 251 } else { 252 // We reverse the iterators. 253 EncodeRow<InputStruct>(std::reverse_iterator<const uint32*>(row_end), 254 std::reverse_iterator<const uint32*>(pos), 255 monochrome, 256 output); 257 } 258 } 259 return true; 260 } 261 262 } // namespace cloud_print 263
