[thirdparty/cups.git] / pdftops / SplashBitmap.cxx

//========================================================================
//
// SplashBitmap.cc
//
//========================================================================

#include <config.h>

#ifdef USE_GCC_PRAGMAS
#pragma implementation
#endif

#include <stdio.h>
#include "gmem.h"
#include "SplashErrorCodes.h"
#include "SplashBitmap.h"

//------------------------------------------------------------------------
// SplashBitmap
//------------------------------------------------------------------------

SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPad,
			   SplashColorMode modeA, GBool topDown) {
  width = widthA;
  height = heightA;
  mode = modeA;
  switch (mode) {
  case splashModeMono1:
    rowSize = (width + 7) >> 3;
    break;
  case splashModeMono8:
    rowSize = width;
    break;
  case splashModeAMono8:
    rowSize = width * 2;
    break;
  case splashModeRGB8:
  case splashModeBGR8:
    rowSize = width * 3;
    break;
  case splashModeARGB8:
  case splashModeBGRA8:
#if SPLASH_CMYK
  case splashModeCMYK8:
#endif
    rowSize = width * 4;
    break;
#if SPLASH_CMYK
  case splashModeACMYK8:
    rowSize = width * 5;
    break;
#endif
  }
  rowSize += rowPad - 1;
  rowSize -= rowSize % rowPad;
  data = (SplashColorPtr)gmalloc(rowSize * height);
  if (!topDown) {
    data += (height - 1) * rowSize;
    rowSize = -rowSize;
  }
}


SplashBitmap::~SplashBitmap() {
  if (rowSize < 0) {
    gfree(data + (height - 1) * rowSize);
  } else {
    gfree(data);
  }
}

SplashError SplashBitmap::writePNMFile(char *fileName) {
  FILE *f;
  SplashColorPtr row, p;
  int x, y;

  if (!(f = fopen(fileName, "wb"))) {
    return splashErrOpenFile;
  }

  switch (mode) {

  case splashModeMono1:
    fprintf(f, "P4\n%d %d\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; x += 8) {
	fputc(*p ^ 0xff, f);
	++p;
      }
      row += rowSize;
    }
    break;

  case splashModeMono8:
    fprintf(f, "P5\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(*p, f);
	++p;
      }
      row += rowSize;
    }
    break;

  case splashModeAMono8:
    fprintf(f, "P5\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashAMono8M(p), f);
	p += 2;
      }
      row += rowSize;
    }
    break;

  case splashModeRGB8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashRGB8R(p), f);
	fputc(splashRGB8G(p), f);
	fputc(splashRGB8B(p), f);
	p += 3;
      }
      row += rowSize;
    }
    break;

  case splashModeBGR8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashBGR8R(p), f);
	fputc(splashBGR8G(p), f);
	fputc(splashBGR8B(p), f);
	p += 3;
      }
      row += rowSize;
    }
    break;

  case splashModeARGB8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashARGB8R(p), f);
	fputc(splashARGB8G(p), f);
	fputc(splashARGB8B(p), f);
	p += 4;
      }
      row += rowSize;
    }
    break;

  case splashModeBGRA8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashBGRA8R(p), f);
	fputc(splashBGRA8G(p), f);
	fputc(splashBGRA8B(p), f);
	p += 4;
      }
      row += rowSize;
    }
    break;

#if SPLASH_CMYK
  case splashModeCMYK8:
  case splashModeACMYK8:
    // PNM doesn't support CMYK
    break;
#endif
  }

  fclose(f);
  return splashOk;
}

void SplashBitmap::getPixel(int x, int y, SplashColorPtr pixel) {
  SplashColorPtr p;

  if (y < 0 || y >= height || x < 0 || x >= width) {
    return;
  }
  switch (mode) {
  case splashModeMono1:
    p = &data[y * rowSize + (x >> 3)];
    pixel[0] = (p[0] >> (7 - (x & 7))) & 1;
    break;
  case splashModeMono8:
    p = &data[y * rowSize + x];
    pixel[0] = p[0];
    break;
  case splashModeAMono8:
    p = &data[y * rowSize + 2 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    break;
  case splashModeRGB8:
  case splashModeBGR8:
    p = &data[y * rowSize + 3 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    pixel[2] = p[2];
    break;
  case splashModeARGB8:
  case splashModeBGRA8:
#if SPLASH_CMYK
  case splashModeCMYK8:
#endif
    p = &data[y * rowSize + 4 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    pixel[2] = p[2];
    pixel[3] = p[3];
    break;
#if SPLASH_CMYK
  case splashModeACMYK8:
    p = &data[y * rowSize + 5 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    pixel[2] = p[2];
    pixel[3] = p[3];
    pixel[4] = p[4];
    break;
#endif
  }
}
Commit	Line	Data
ef416fc2	1	//========================================================================
	2	//
	3	// SplashBitmap.cc
	4	//
	5	//========================================================================
	6
	7	#include <config.h>
	8
	9	#ifdef USE_GCC_PRAGMAS
	10	#pragma implementation
	11	#endif
	12
	13	#include <stdio.h>
	14	#include "gmem.h"
	15	#include "SplashErrorCodes.h"
	16	#include "SplashBitmap.h"
	17
	18	//------------------------------------------------------------------------
	19	// SplashBitmap
	20	//------------------------------------------------------------------------
	21
	22	SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPad,
	23	SplashColorMode modeA, GBool topDown) {
	24	width = widthA;
	25	height = heightA;
	26	mode = modeA;
	27	switch (mode) {
	28	case splashModeMono1:
	29	rowSize = (width + 7) >> 3;
	30	break;
	31	case splashModeMono8:
	32	rowSize = width;
	33	break;
	34	case splashModeAMono8:
	35	rowSize = width * 2;
	36	break;
	37	case splashModeRGB8:
	38	case splashModeBGR8:
	39	rowSize = width * 3;
	40	break;
	41	case splashModeARGB8:
	42	case splashModeBGRA8:
	43	#if SPLASH_CMYK
	44	case splashModeCMYK8:
	45	#endif
	46	rowSize = width * 4;
	47	break;
	48	#if SPLASH_CMYK
	49	case splashModeACMYK8:
	50	rowSize = width * 5;
	51	break;
	52	#endif
	53	}
	54	rowSize += rowPad - 1;
	55	rowSize -= rowSize % rowPad;
	56	data = (SplashColorPtr)gmalloc(rowSize * height);
	57	if (!topDown) {
	58	data += (height - 1) * rowSize;
	59	rowSize = -rowSize;
	60	}
	61	}
	62
	63
	64	SplashBitmap::~SplashBitmap() {
65	if (rowSize < 0) {
66	gfree(data + (height - 1) * rowSize);
67	} else {
68	gfree(data);
69	}
70	}
71
72	SplashError SplashBitmap::writePNMFile(char *fileName) {
73	FILE *f;
74	SplashColorPtr row, p;
75	int x, y;
76
77	if (!(f = fopen(fileName, "wb"))) {
78	return splashErrOpenFile;
79	}
80
81	switch (mode) {
82
83	case splashModeMono1:
84	fprintf(f, "P4\n%d %d\n", width, height);
85	row = data;
86	for (y = 0; y < height; ++y) {
87	p = row;
88	for (x = 0; x < width; x += 8) {
89	fputc(*p ^ 0xff, f);
90	++p;
91	}
92	row += rowSize;
93	}
94	break;
95
96	case splashModeMono8:
97	fprintf(f, "P5\n%d %d\n255\n", width, height);
98	row = data;
99	for (y = 0; y < height; ++y) {
100	p = row;
101	for (x = 0; x < width; ++x) {
102	fputc(*p, f);
103	++p;
104	}
105	row += rowSize;
106	}
107	break;
108
109	case splashModeAMono8:
110	fprintf(f, "P5\n%d %d\n255\n", width, height);
111	row = data;
112	for (y = 0; y < height; ++y) {
113	p = row;
114	for (x = 0; x < width; ++x) {
115	fputc(splashAMono8M(p), f);
116	p += 2;
117	}
118	row += rowSize;
119	}
120	break;
121
122	case splashModeRGB8:
123	fprintf(f, "P6\n%d %d\n255\n", width, height);
124	row = data;
125	for (y = 0; y < height; ++y) {
126	p = row;
127	for (x = 0; x < width; ++x) {
128	fputc(splashRGB8R(p), f);
129	fputc(splashRGB8G(p), f);
130	fputc(splashRGB8B(p), f);
131	p += 3;
132	}
133	row += rowSize;
134	}
135	break;
136
137	case splashModeBGR8:
138	fprintf(f, "P6\n%d %d\n255\n", width, height);
139	row = data;
140	for (y = 0; y < height; ++y) {
141	p = row;
142	for (x = 0; x < width; ++x) {
143	fputc(splashBGR8R(p), f);
144	fputc(splashBGR8G(p), f);
145	fputc(splashBGR8B(p), f);
146	p += 3;
147	}
148	row += rowSize;
149	}
150	break;
151
152	case splashModeARGB8:
153	fprintf(f, "P6\n%d %d\n255\n", width, height);
154	row = data;
155	for (y = 0; y < height; ++y) {
156	p = row;
157	for (x = 0; x < width; ++x) {
158	fputc(splashARGB8R(p), f);
159	fputc(splashARGB8G(p), f);
160	fputc(splashARGB8B(p), f);
161	p += 4;
162	}
163	row += rowSize;
164	}
165	break;
166
167	case splashModeBGRA8:
168	fprintf(f, "P6\n%d %d\n255\n", width, height);
169	row = data;
170	for (y = 0; y < height; ++y) {
171	p = row;
172	for (x = 0; x < width; ++x) {
173	fputc(splashBGRA8R(p), f);
174	fputc(splashBGRA8G(p), f);
175	fputc(splashBGRA8B(p), f);
176	p += 4;
177	}
178	row += rowSize;
179	}
180	break;
181
182	#if SPLASH_CMYK
183	case splashModeCMYK8:
184	case splashModeACMYK8:
185	// PNM doesn't support CMYK
186	break;
187	#endif
188	}
189
190	fclose(f);
191	return splashOk;
192	}
193
194	void SplashBitmap::getPixel(int x, int y, SplashColorPtr pixel) {
195	SplashColorPtr p;
196
197	if (y < 0 \|\| y >= height \|\| x < 0 \|\| x >= width) {
198	return;
199	}
200	switch (mode) {
201	case splashModeMono1:
202	p = &data[y * rowSize + (x >> 3)];
203	pixel[0] = (p[0] >> (7 - (x & 7))) & 1;
204	break;
205	case splashModeMono8:
206	p = &data[y * rowSize + x];
207	pixel[0] = p[0];
208	break;
209	case splashModeAMono8:
210	p = &data[y * rowSize + 2 * x];
211	pixel[0] = p[0];
212	pixel[1] = p[1];
213	break;
214	case splashModeRGB8:
215	case splashModeBGR8:
216	p = &data[y * rowSize + 3 * x];
217	pixel[0] = p[0];
218	pixel[1] = p[1];
219	pixel[2] = p[2];
220	break;
221	case splashModeARGB8:
222	case splashModeBGRA8:
223	#if SPLASH_CMYK
224	case splashModeCMYK8:
225	#endif
226	p = &data[y * rowSize + 4 * x];
227	pixel[0] = p[0];
228	pixel[1] = p[1];
229	pixel[2] = p[2];
230	pixel[3] = p[3];
231	break;
232	#if SPLASH_CMYK
233	case splashModeACMYK8:
234	p = &data[y * rowSize + 5 * x];
235	pixel[0] = p[0];
236	pixel[1] = p[1];
237	pixel[2] = p[2];
238	pixel[3] = p[3];
239	pixel[4] = p[4];
240	break;
241	#endif
242	}
243	}