Add 16-bit support, and related clean-ups

attah · attah · commit cb7de0755d19 · 2024-11-29T20:20:17.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,6 @@
 .vscode
 *.o
+*.plist
 tests/test
 tests/*.o
 tests/_test_pdf2printable_16x9_*
diff --git a/README.md b/README.md
@@ -8,9 +8,7 @@
 Available as rudimentary standalone applications, but mainly made for use in [SeaPrint](https://github.com/attah/harbour-seaprint).
 
 ## ppm2pwg
-Takes a pbm, pgm or ppm (P4, P5 or P6 "raw") Netpbm bitmap image and converts to PWG or URF printer raster format.
-
-...or a raw bitmap in the c++ api.
+Takes a pbm, pgm or ppm (P4, P5 or P6 "raw") Netpbm bitmap image and converts to PWG or URF printer raster format. Supports 1, 8 and **16** bits per color.
 
 ## pwg2ppm
 For debugging. Similar to [rasterview](https://github.com/michaelrsweet/rasterview), but without a GUI. Takes a PWG or URF printer raster and outputs a series of P4, P5 or P6 pbm/pgm/ppm images.
@@ -24,7 +22,7 @@ Takes a PDF document and makes it suitable for printing, by:
 
 ## baselinify
 Takes a JPEG and losslessly repacks it to the baseline ecoding profile, keeping only JFIF and Exif headers.
-Sort of like jpegtran without any arguments, but reusable in C++.
+Sort of like jpegtran without any arguments.
 
 IPP-printers are only required to support baseline-encoded jpeg according to PWG5100.14.
 
diff --git a/lib/pdf2printable.cpp b/lib/pdf2printable.cpp
@@ -300,6 +300,10 @@ void copy_raster_buffer(Bytestream& bmpBts, uint32_t* data, const PrintParameter
       }
       break;
     }
+    default:
+    {
+      throw std::logic_error("Unhandled color mode");
+    }
   }
 }
 
diff --git a/lib/ppm2pwg.cpp b/lib/ppm2pwg.cpp
@@ -10,6 +10,12 @@
 #include <map>
 #include <string.h>
 
+void make_pwg_hdr(Bytestream& outBts, const PrintParameters& params, bool backside);
+void make_urf_hdr(Bytestream& outBts, const PrintParameters& params);
+
+void compress_lines(Bytestream& bmpBts, Bytestream& outBts, const PrintParameters& params, bool backside);
+void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, size_t oneChunk);
+
 Bytestream make_pwg_file_hdr()
 {
   Bytestream pwgFileHdr;
@@ -42,21 +48,27 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print
   size_t yRes = params.getPaperSizeHInPixels();
   uint8_t* raw = bmpBts.raw();
   size_t bytesPerLine = params.getPaperSizeWInBytes();
-  int step = backside&&params.getBackVFlip() ? -bytesPerLine : bytesPerLine;
-  uint8_t* row0 = backside&&params.getBackVFlip() ? raw+(yRes-1)*bytesPerLine : raw;
+  int oneLine = backside && params.getBackVFlip() ? -bytesPerLine : bytesPerLine;
+  uint8_t* row0 = backside && params.getBackVFlip() ? raw + (yRes - 1) * bytesPerLine : raw;
   Array<uint8_t> tmpLine(bytesPerLine);
 
-  for(size_t y=0; y<yRes; y++)
+  size_t colors = params.getNumberOfColors();
+  size_t bpc = params.getBitsPerColor();
+  // A chunk is the unit used for compression.
+  // Usually this is the number of bytes per color times the number of colors,
+  // but for 1-bit, compression is applied in whole bytes.
+  size_t oneChunk = bpc == 1 ? colors : colors * bpc / 8;
+
+  for(size_t y = 0; y < yRes; y++)
   {
-    uint8_t* thisLine = row0+y*step;
+    uint8_t* thisLine = row0 + y * oneLine;
     uint8_t lineRepeat = 0;
-    size_t colors = params.getNumberOfColors();
 
-    uint8_t* next_line = thisLine + step;
+    uint8_t* next_line = thisLine + oneLine;
     while((y+1)<yRes && memcmp(thisLine, next_line, bytesPerLine) == 0)
     {
       y++;
-      next_line += step;
+      next_line += oneLine;
       lineRepeat++;
       if(lineRepeat == 255)
       {
@@ -68,7 +80,7 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print
     if(backside && params.getBackHFlip())
     {
       // Flip line into tmp buffer
-      if(params.getBitsPerColor() == 1)
+      if(bpc == 1)
       {
         for(size_t i = 0; i < bytesPerLine; i++)
         {
@@ -78,46 +90,48 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print
       }
       else
       {
-        for(size_t i = 0; i < bytesPerLine; i += colors)
+        uint8_t* lastChunk = thisLine + bytesPerLine - oneChunk;
+        for(size_t i = 0; i < bytesPerLine; i += oneChunk)
         {
-          memcpy(tmpLine+i, thisLine+bytesPerLine-colors-i, colors);
+          memcpy(tmpLine+i, lastChunk-i, oneChunk);
         }
       }
-      compress_line(tmpLine, bytesPerLine, outBts, colors);
+      compress_line(tmpLine, bytesPerLine, outBts, oneChunk);
     }
     else
     {
-      compress_line(thisLine, bytesPerLine, outBts, colors);
+      compress_line(thisLine, bytesPerLine, outBts, oneChunk);
     }
   }
 }
 
-void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)
+void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, size_t oneChunk)
 {
   uint8_t* current;
   uint8_t* pos = raw;
-  uint8_t* epos = raw+len;
+  uint8_t* epos = raw + len;
+
   while(pos != epos)
   {
     uint8_t* currentStart = pos;
     current = pos;
-    pos += colors;
+    pos += oneChunk;
 
-    if(pos == epos || memcmp(pos, current, colors) == 0)
+    if(pos == epos || memcmp(pos, current, oneChunk) == 0)
     {
       int8_t repeat = 0;
       // Find number of repititions
-      while(pos != epos && memcmp(pos, current, colors) == 0)
+      while(pos != epos && memcmp(pos, current, oneChunk) == 0)
       {
-        pos += colors;
+        pos += oneChunk;
         repeat++;
         if(repeat == 127)
         {
           break;
         }
       }
       outBts << repeat;
-      outBts.putBytes(current, colors);
+      outBts.putBytes(current, oneChunk);
     }
     else
     {
@@ -127,14 +141,14 @@ void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)
       do
       {
         current = pos;
-        pos += colors;
+        pos += oneChunk;
         verbatim++;
         if(verbatim == 127)
         {
           break;
         }
       }
-      while(pos != epos && memcmp(pos, current, colors) != 0);
+      while(pos != epos && memcmp(pos, current, oneChunk) != 0);
 
       // This and the next sequence are equal,
       // assume it starts a repeating sequence.
@@ -148,15 +162,15 @@ void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)
       // But in order to not lean on that (uint8_t)(256)==0, we have this.
       if(verbatim == 1)
       { // We ended up with one sequence, encode it as such
-        pos = currentStart + colors;
+        pos = currentStart + oneChunk;
         outBts << (uint8_t)0;
-        outBts.putBytes(currentStart, colors);
+        outBts.putBytes(currentStart, oneChunk);
       }
       else
       { // 2 or more non-repeating sequnces
-        pos = currentStart + verbatim*colors;
-        outBts << (uint8_t)(257-verbatim);
-        outBts.putBytes(currentStart, verbatim*colors);
+        pos = currentStart + verbatim * oneChunk;
+        outBts << (uint8_t)(257 - verbatim);
+        outBts.putBytes(currentStart, verbatim * oneChunk);
       }
     }
   }
@@ -193,7 +207,9 @@ void make_pwg_hdr(Bytestream& outBts, const PrintParameters& params, bool backsi
                            {PrintParameters::Gray8, PwgPgHdr::sGray},
                            {PrintParameters::Black8, PwgPgHdr::Black},
                            {PrintParameters::Gray1, PwgPgHdr::sGray},
-                           {PrintParameters::Black1, PwgPgHdr::Black}};
+                           {PrintParameters::Black1, PwgPgHdr::Black},
+                           {PrintParameters::sRGB48, PwgPgHdr::sRGB},
+                           {PrintParameters::Gray16, PwgPgHdr::sGray}};
 
   outHdr.MediaType = params.mediaType;
   outHdr.Duplex = params.isTwoSided();
@@ -235,14 +251,16 @@ void make_urf_hdr(Bytestream& outBts, const PrintParameters& params)
   static const std::map<PrintParameters::ColorMode, UrfPgHdr::ColorSpace_enum>
     urfColorSpaceMappings {{PrintParameters::sRGB24, UrfPgHdr::sRGB},
                            {PrintParameters::CMYK32, UrfPgHdr::CMYK},
-                           {PrintParameters::Gray8, UrfPgHdr::sGray}};
+                           {PrintParameters::Gray8, UrfPgHdr::sGray},
+                           {PrintParameters::sRGB48, UrfPgHdr::sRGB},
+                           {PrintParameters::Gray16, UrfPgHdr::sGray}};
 
   static const std::map<PrintParameters::DuplexMode, UrfPgHdr::Duplex_enum>
     urfDuplexMappings {{PrintParameters::OneSided, UrfPgHdr::OneSided},
                        {PrintParameters::TwoSidedLongEdge, UrfPgHdr::TwoSidedLongEdge},
                        {PrintParameters::TwoSidedShortEdge, UrfPgHdr::TwoSidedShortEdge}};
 
-  outHdr.BitsPerPixel = 8*params.getNumberOfColors();
+  outHdr.BitsPerPixel = params.getNumberOfColors() * params.getBitsPerColor();
   outHdr.ColorSpace = urfColorSpaceMappings.at(params.colorMode);
   outHdr.Duplex = urfDuplexMappings.at(params.duplexMode);
   outHdr.setQuality(params.quality);
diff --git a/lib/ppm2pwg.h b/lib/ppm2pwg.h
@@ -10,17 +10,7 @@ Bytestream make_pwg_file_hdr();
 
 Bytestream make_urf_file_hdr(uint32_t pages);
 
-void make_pwg_hdr(Bytestream& outBts, const PrintParameters& params, bool backside);
-void make_urf_hdr(Bytestream& outBts, const PrintParameters& params);
-
-
-void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page,
-                const PrintParameters& params);
-
-void compress_lines(Bytestream& bmpBts, Bytestream& outBts,
-                    const PrintParameters& params, bool backside);
-
-void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int Colors);
+void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const PrintParameters& params);
 
 bool isUrfMediaType(std::string mediaType);
 
diff --git a/lib/printparameters.cpp b/lib/printparameters.cpp
@@ -110,14 +110,18 @@ double PrintParameters::getPaperSizeHInPoints() const
 
 size_t PrintParameters::getPaperSizeWInBytes() const
 {
-  if(getBitsPerColor() == 1)
+  if(getBitsPerColor() == 1 && getNumberOfColors() == 1)
   {
     // Round up to whole bytes
-    return getNumberOfColors() * ((getPaperSizeWInPixels() + 7) / 8);
+    return (getPaperSizeWInPixels() + 7) / 8;
+  }
+  else if(getBitsPerColor() % 8 == 0)
+  {
+    return getPaperSizeWInPixels() * getNumberOfColors() * (getBitsPerColor() / 8);
   }
   else
   {
-    return getNumberOfColors() * (getPaperSizeWInPixels() / (8 / getBitsPerColor()));
+    throw(std::logic_error("Unhandled color and bit depth combination"));
   }
 }
 
@@ -272,6 +276,8 @@ bool PrintParameters::isBlack() const
     case CMYK32:
     case Gray8:
     case Gray1:
+    case sRGB48:
+    case Gray16:
       return false;
     case Black8:
     case Black1:
@@ -286,13 +292,15 @@ size_t PrintParameters::getNumberOfColors() const
   switch(colorMode)
   {
     case sRGB24:
+    case sRGB48:
       return 3;
     case CMYK32:
       return 4;
     case Gray8:
     case Black8:
     case Gray1:
     case Black1:
+    case Gray16:
       return 1;
     default:
       throw(std::logic_error("Unknown color mode"));
@@ -311,6 +319,9 @@ size_t PrintParameters::getBitsPerColor() const
     case Gray1:
     case Black1:
       return 1;
+    case sRGB48:
+    case Gray16:
+      return 16;
     default:
       throw(std::logic_error("Unknown color mode"));
   }
diff --git a/lib/printparameters.h b/lib/printparameters.h
@@ -32,7 +32,9 @@ class PrintParameters
     Gray8,
     Black8,
     Gray1,
-    Black1
+    Black1,
+    sRGB48,
+    Gray16
   };
 
   enum Quality
diff --git a/tests/Makefile b/tests/Makefile
@@ -1,7 +1,7 @@
 LDFLAGS = -ldl -Wl,--export-dynamic -lcurl -ljpeg $(shell pkg-config --libs poppler-glib) -lz
 CXXFLAGS = -std=c++17 -g -pedantic -Wall -Werror -Wextra -I ../lib -I ../json11 -I ../bytestream \
 $(shell pkg-config --cflags poppler-glib)
-TEST_INCLUDES = -I ../lib -I ../bytestream/minitest -I ../bytestream/minitest/tests
+TEST_INCLUDES = -I ../lib -I ../bytestream/minitest
 
 VPATH = ../bytestream ../lib ../json11
 
diff --git a/tests/test.cpp b/tests/test.cpp
diff --git a/utils/ppm2pwg_main.cpp b/utils/ppm2pwg_main.cpp

Original file line number	Diff line number	Diff line change
`@@ -300,6 +300,10 @@ void copy_raster_buffer(Bytestream& bmpBts, uint32_t* data, const PrintParameter`
`300`	`300`	`}`
`301`	`301`	`break;`
`302`	`302`	`}`
	`303`	`+ default:`
	`304`	`+ {`
	`305`	`+ throw std::logic_error("Unhandled color mode");`
	`306`	`+ }`
`303`	`307`	`}`
`304`	`308`	`}`
`305`	`309`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,12 @@`
`10`	`10`	`#include <map>`
`11`	`11`	`#include <string.h>`
`12`	`12`
	`13`	`+void make_pwg_hdr(Bytestream& outBts, const PrintParameters& params, bool backside);`
	`14`	`+void make_urf_hdr(Bytestream& outBts, const PrintParameters& params);`
	`15`	`+`
	`16`	`+void compress_lines(Bytestream& bmpBts, Bytestream& outBts, const PrintParameters& params, bool backside);`
	`17`	`+void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, size_t oneChunk);`
	`18`	`+`
`13`	`19`	`Bytestream make_pwg_file_hdr()`
`14`	`20`	`{`
`15`	`21`	`Bytestream pwgFileHdr;`
`@@ -42,21 +48,27 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print`
`42`	`48`	`size_t yRes = params.getPaperSizeHInPixels();`
`43`	`49`	`uint8_t* raw = bmpBts.raw();`
`44`	`50`	`size_t bytesPerLine = params.getPaperSizeWInBytes();`
`45`		`- int step = backside&&params.getBackVFlip() ? -bytesPerLine : bytesPerLine;`
`46`		`- uint8_t* row0 = backside&&params.getBackVFlip() ? raw+(yRes-1)*bytesPerLine : raw;`
	`51`	`+ int oneLine = backside && params.getBackVFlip() ? -bytesPerLine : bytesPerLine;`
	`52`	`+ uint8_t* row0 = backside && params.getBackVFlip() ? raw + (yRes - 1) * bytesPerLine : raw;`
`47`	`53`	`Array<uint8_t> tmpLine(bytesPerLine);`
`48`	`54`
`49`		`- for(size_t y=0; y<yRes; y++)`
	`55`	`+ size_t colors = params.getNumberOfColors();`
	`56`	`+ size_t bpc = params.getBitsPerColor();`
	`57`	`+ // A chunk is the unit used for compression.`
	`58`	`+ // Usually this is the number of bytes per color times the number of colors,`
	`59`	`+ // but for 1-bit, compression is applied in whole bytes.`
	`60`	`+ size_t oneChunk = bpc == 1 ? colors : colors * bpc / 8;`
	`61`	`+`
	`62`	`+ for(size_t y = 0; y < yRes; y++)`
`50`	`63`	`{`
`51`		`- uint8_t* thisLine = row0+y*step;`
	`64`	`+ uint8_t* thisLine = row0 + y * oneLine;`
`52`	`65`	`uint8_t lineRepeat = 0;`
`53`		`- size_t colors = params.getNumberOfColors();`
`54`	`66`
`55`		`- uint8_t* next_line = thisLine + step;`
	`67`	`+ uint8_t* next_line = thisLine + oneLine;`
`56`	`68`	`while((y+1)<yRes && memcmp(thisLine, next_line, bytesPerLine) == 0)`
`57`	`69`	`{`
`58`	`70`	`y++;`
`59`		`- next_line += step;`
	`71`	`+ next_line += oneLine;`
`60`	`72`	`lineRepeat++;`
`61`	`73`	`if(lineRepeat == 255)`
`62`	`74`	`{`
`@@ -68,7 +80,7 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print`
`68`	`80`	`if(backside && params.getBackHFlip())`
`69`	`81`	`{`
`70`	`82`	`// Flip line into tmp buffer`
`71`		`- if(params.getBitsPerColor() == 1)`
	`83`	`+ if(bpc == 1)`
`72`	`84`	`{`
`73`	`85`	`for(size_t i = 0; i < bytesPerLine; i++)`
`74`	`86`	`{`
`@@ -78,46 +90,48 @@ void bmp_to_pwg(Bytestream& bmpBts, Bytestream& outBts, size_t page, const Print`
`78`	`90`	`}`
`79`	`91`	`else`
`80`	`92`	`{`
`81`		`- for(size_t i = 0; i < bytesPerLine; i += colors)`
	`93`	`+ uint8_t* lastChunk = thisLine + bytesPerLine - oneChunk;`
	`94`	`+ for(size_t i = 0; i < bytesPerLine; i += oneChunk)`
`82`	`95`	`{`
`83`		`- memcpy(tmpLine+i, thisLine+bytesPerLine-colors-i, colors);`
	`96`	`+ memcpy(tmpLine+i, lastChunk-i, oneChunk);`
`84`	`97`	`}`
`85`	`98`	`}`
`86`		`- compress_line(tmpLine, bytesPerLine, outBts, colors);`
	`99`	`+ compress_line(tmpLine, bytesPerLine, outBts, oneChunk);`
`87`	`100`	`}`
`88`	`101`	`else`
`89`	`102`	`{`
`90`		`- compress_line(thisLine, bytesPerLine, outBts, colors);`
	`103`	`+ compress_line(thisLine, bytesPerLine, outBts, oneChunk);`
`91`	`104`	`}`
`92`	`105`	`}`
`93`	`106`	`}`
`94`	`107`
`95`		`-void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)`
	`108`	`+void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, size_t oneChunk)`
`96`	`109`	`{`
`97`	`110`	`uint8_t* current;`
`98`	`111`	`uint8_t* pos = raw;`
`99`		`- uint8_t* epos = raw+len;`
	`112`	`+ uint8_t* epos = raw + len;`
	`113`	`+`
`100`	`114`	`while(pos != epos)`
`101`	`115`	`{`
`102`	`116`	`uint8_t* currentStart = pos;`
`103`	`117`	`current = pos;`
`104`		`- pos += colors;`
	`118`	`+ pos += oneChunk;`
`105`	`119`
`106`		`- if(pos == epos \|\| memcmp(pos, current, colors) == 0)`
	`120`	`+ if(pos == epos \|\| memcmp(pos, current, oneChunk) == 0)`
`107`	`121`	`{`
`108`	`122`	`int8_t repeat = 0;`
`109`	`123`	`// Find number of repititions`
`110`		`- while(pos != epos && memcmp(pos, current, colors) == 0)`
	`124`	`+ while(pos != epos && memcmp(pos, current, oneChunk) == 0)`
`111`	`125`	`{`
`112`		`- pos += colors;`
	`126`	`+ pos += oneChunk;`
`113`	`127`	`repeat++;`
`114`	`128`	`if(repeat == 127)`
`115`	`129`	`{`
`116`	`130`	`break;`
`117`	`131`	`}`
`118`	`132`	`}`
`119`	`133`	`outBts << repeat;`
`120`		`- outBts.putBytes(current, colors);`
	`134`	`+ outBts.putBytes(current, oneChunk);`
`121`	`135`	`}`
`122`	`136`	`else`
`123`	`137`	`{`
`@@ -127,14 +141,14 @@ void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)`
`127`	`141`	`do`
`128`	`142`	`{`
`129`	`143`	`current = pos;`
`130`		`- pos += colors;`
	`144`	`+ pos += oneChunk;`
`131`	`145`	`verbatim++;`
`132`	`146`	`if(verbatim == 127)`
`133`	`147`	`{`
`134`	`148`	`break;`
`135`	`149`	`}`
`136`	`150`	`}`
`137`		`- while(pos != epos && memcmp(pos, current, colors) != 0);`
	`151`	`+ while(pos != epos && memcmp(pos, current, oneChunk) != 0);`
`138`	`152`
`139`	`153`	`// This and the next sequence are equal,`
`140`	`154`	`// assume it starts a repeating sequence.`
`@@ -148,15 +162,15 @@ void compress_line(uint8_t* raw, size_t len, Bytestream& outBts, int colors)`
`148`	`162`	`// But in order to not lean on that (uint8_t)(256)==0, we have this.`
`149`	`163`	`if(verbatim == 1)`
`150`	`164`	`{ // We ended up with one sequence, encode it as such`
`151`		`- pos = currentStart + colors;`
	`165`	`+ pos = currentStart + oneChunk;`
`152`	`166`	`outBts << (uint8_t)0;`
`153`		`- outBts.putBytes(currentStart, colors);`
	`167`	`+ outBts.putBytes(currentStart, oneChunk);`
`154`	`168`	`}`
`155`	`169`	`else`
`156`	`170`	`{ // 2 or more non-repeating sequnces`
`157`		`- pos = currentStart + verbatim*colors;`
`158`		`- outBts << (uint8_t)(257-verbatim);`
`159`		`- outBts.putBytes(currentStart, verbatim*colors);`
	`171`	`+ pos = currentStart + verbatim * oneChunk;`
	`172`	`+ outBts << (uint8_t)(257 - verbatim);`
	`173`	`+ outBts.putBytes(currentStart, verbatim * oneChunk);`
`160`	`174`	`}`
`161`	`175`	`}`
`162`	`176`	`}`
`@@ -193,7 +207,9 @@ void make_pwg_hdr(Bytestream& outBts, const PrintParameters& params, bool backsi`
`193`	`207`	`{PrintParameters::Gray8, PwgPgHdr::sGray},`
`194`	`208`	`{PrintParameters::Black8, PwgPgHdr::Black},`
`195`	`209`	`{PrintParameters::Gray1, PwgPgHdr::sGray},`
`196`		`- {PrintParameters::Black1, PwgPgHdr::Black}};`
	`210`	`+ {PrintParameters::Black1, PwgPgHdr::Black},`
	`211`	`+ {PrintParameters::sRGB48, PwgPgHdr::sRGB},`
	`212`	`+ {PrintParameters::Gray16, PwgPgHdr::sGray}};`
`197`	`213`
`198`	`214`	`outHdr.MediaType = params.mediaType;`
`199`	`215`	`outHdr.Duplex = params.isTwoSided();`
`@@ -235,14 +251,16 @@ void make_urf_hdr(Bytestream& outBts, const PrintParameters& params)`
`235`	`251`	`static const std::map<PrintParameters::ColorMode, UrfPgHdr::ColorSpace_enum>`
`236`	`252`	`urfColorSpaceMappings {{PrintParameters::sRGB24, UrfPgHdr::sRGB},`
`237`	`253`	`{PrintParameters::CMYK32, UrfPgHdr::CMYK},`
`238`		`- {PrintParameters::Gray8, UrfPgHdr::sGray}};`
	`254`	`+ {PrintParameters::Gray8, UrfPgHdr::sGray},`
	`255`	`+ {PrintParameters::sRGB48, UrfPgHdr::sRGB},`
	`256`	`+ {PrintParameters::Gray16, UrfPgHdr::sGray}};`
`239`	`257`
`240`	`258`	`static const std::map<PrintParameters::DuplexMode, UrfPgHdr::Duplex_enum>`
`241`	`259`	`urfDuplexMappings {{PrintParameters::OneSided, UrfPgHdr::OneSided},`
`242`	`260`	`{PrintParameters::TwoSidedLongEdge, UrfPgHdr::TwoSidedLongEdge},`
`243`	`261`	`{PrintParameters::TwoSidedShortEdge, UrfPgHdr::TwoSidedShortEdge}};`
`244`	`262`
`245`		`- outHdr.BitsPerPixel = 8*params.getNumberOfColors();`
	`263`	`+ outHdr.BitsPerPixel = params.getNumberOfColors() * params.getBitsPerColor();`
`246`	`264`	`outHdr.ColorSpace = urfColorSpaceMappings.at(params.colorMode);`
`247`	`265`	`outHdr.Duplex = urfDuplexMappings.at(params.duplexMode);`
`248`	`266`	`outHdr.setQuality(params.quality);`
-Original file line number
+Diff line change
     Gray8,
     Black8,
     Gray1,
 -    Black1
 +    Black1,
 +    sRGB48,
 +    Gray16
   };
   enum Quality