void _cmsFree(void *ptr)
{
if (ptr != NULL) {
gs_warn1("lcms free at 0x%x",ptr);
gs_free_object(gs_lib_ctx_get_non_gc_memory_t(), ptr, "lcms");
}
}
/*
* Strip alpha channel from an image
* assumes a collapsed stride
*/
static void
gslt_strip_alpha(gslt_image_t *image)
{
gslt_image_colorspace cs = image->colorspace;
int n = image->components;
int y, x, k;
byte *sp, *dp;
if (image->bits != 8)
{
gs_warn1("cannot strip alpha from %dbpc images", image->bits);
return;
}
if ((cs != GSLT_GRAY_A) && (cs != GSLT_RGB_A) && (cs != GSLT_CMYK_A))
return;
for (y = 0; y < image->height; y++)
{
sp = image->samples + image->width * n * y;
dp = image->samples + image->width * (n - 1) * y;
for (x = 0; x < image->width; x++)
{
for (k = 0; k < n - 1; k++)
*dp++ = *sp++;
sp++;
}
}
image->colorspace --; /* assume foo_A follows foo */
image->components --;
image->stride = (n - 1) * image->width;
}
/* Only provide warning about issues in lcms if debug build */
static int
gscms_error(int error_code, const char *error_text){
#ifdef DEBUG
gs_warn1("cmm error : %s",error_text);
#endif
return(1);
}
/* Only provide warning about issues in lcms if debug build */
static void
gscms_error(cmsContext ContextID,
cmsUInt32Number error_code,
const char *error_text)
{
#ifdef DEBUG
gs_warn1("cmm error : %s",error_text);
#endif
}
void _cmsFree(void *ptr)
{
if (ptr != NULL) {
gs_warn1("lcms free at 0x%x",ptr);
#if defined(SHARE_LCMS) && SHARE_LCMS==1
free(ptr);
#else
gs_free_object(gs_lib_ctx_get_non_gc_memory_t(), ptr, "lcms");
#endif
}
}
static
void gs_lcms2_free(cmsContext id, void *ptr)
{
gs_memory_t *mem = (gs_memory_t *)id;
if (ptr != NULL) {
#if DEBUG_LCMS_MEM
gs_warn1("lcms free at 0x%x",ptr);
#endif
#if defined(SHARE_LCMS) && SHARE_LCMS==1
free(ptr);
#else
gs_free_object(mem, ptr, "lcms");
#endif
}
}
static int
xps_encode_font_char_imp(xps_font_t *font, int code)
{
byte *table;
/* no cmap selected: return identity */
if (font->cmapsubtable <= 0)
return code;
table = font->data + font->cmapsubtable;
switch (u16(table))
{
case 0: /* Apple standard 1-to-1 mapping. */
return table[code + 6];
case 4: /* Microsoft/Adobe segmented mapping. */
{
int segCount2 = u16(table + 6);
byte *endCount = table + 14;
byte *startCount = endCount + segCount2 + 2;
byte *idDelta = startCount + segCount2;
byte *idRangeOffset = idDelta + segCount2;
int i2;
for (i2 = 0; i2 < segCount2 - 3; i2 += 2)
{
int delta, roff;
int start = u16(startCount + i2);
int glyph;
if ( code < start )
return 0;
if ( code > u16(endCount + i2) )
continue;
delta = s16(idDelta + i2);
roff = s16(idRangeOffset + i2);
if ( roff == 0 )
{
return ( code + delta ) & 0xffff; /* mod 65536 */
return 0;
}
glyph = u16(idRangeOffset + i2 + roff + ((code - start) << 1));
return (glyph == 0 ? 0 : glyph + delta);
}
/*
* The TrueType documentation says that the last range is
* always supposed to end with 0xffff, so this shouldn't
* happen; however, in some real fonts, it does.
*/
return 0;
}
case 6: /* Single interval lookup. */
{
int firstCode = u16(table + 6);
int entryCount = u16(table + 8);
if ( code < firstCode || code >= firstCode + entryCount )
return 0;
return u16(table + 10 + ((code - firstCode) << 1));
}
case 10: /* Trimmed array (like 6) */
{
int startCharCode = u32(table + 12);
int numChars = u32(table + 16);
if ( code < startCharCode || code >= startCharCode + numChars )
return 0;
return u32(table + 20 + (code - startCharCode) * 4);
}
case 12: /* Segmented coverage. (like 4) */
{
int nGroups = u32(table + 12);
byte *group = table + 16;
int i;
for (i = 0; i < nGroups; i++)
{
int startCharCode = u32(group + 0);
int endCharCode = u32(group + 4);
int startGlyphID = u32(group + 8);
if ( code < startCharCode )
return 0;
if ( code <= endCharCode )
return startGlyphID + (code - startCharCode);
group += 12;
}
return 0;
}
case 2: /* High-byte mapping through table. */
case 8: /* Mixed 16-bit and 32-bit coverage (like 2) */
default:
gs_warn1("unknown cmap format: %d\n", u16(table));
return 0;
}
return 0;
}
/* (de)crypt a section of text--the procedure is the same
* in each direction. see strimpl.h for return codes.
*/
static int
s_aes_process(stream_state * ss, stream_cursor_read * pr,
stream_cursor_write * pw, bool last)
{
stream_aes_state *const state = (stream_aes_state *) ss;
const unsigned char *limit;
const long in_size = pr->limit - pr->ptr;
const long out_size = pw->limit - pw->ptr;
unsigned char temp[16];
int status = 0;
/* figure out if we're going to run out of space */
if (in_size > out_size) {
limit = pr->ptr + out_size;
status = 1; /* need more output space */
} else {
limit = pr->limit;
status = last ? EOFC : 0; /* need more input */
}
/* set up state and context */
if (state->ctx == NULL) {
/* allocate the aes context. this is a public struct but it
contains internal pointers, so we need to store it separately
in immovable memory like any opaque structure. */
state->ctx = (aes_context *)gs_alloc_bytes_immovable(state->memory,
sizeof(aes_context), "aes context structure");
if (state->ctx == NULL) {
gs_throw(gs_error_VMerror, "could not allocate aes context");
return ERRC;
}
if (state->keylength < 1 || state->keylength > SAES_MAX_KEYLENGTH) {
gs_throw1(gs_error_rangecheck, "invalid aes key length (%d bytes)",
state->keylength);
return ERRC;
}
aes_setkey_dec(state->ctx, state->key, state->keylength * 8);
}
if (!state->initialized) {
/* read the initialization vector from the first 16 bytes */
if (in_size < 16) return 0; /* get more data */
memcpy(state->iv, pr->ptr + 1, 16);
state->initialized = 1;
pr->ptr += 16;
}
/* decrypt available blocks */
while (pr->ptr + 16 <= limit) {
aes_crypt_cbc(state->ctx, AES_DECRYPT, 16, state->iv,
pr->ptr + 1, temp);
pr->ptr += 16;
if (last && pr->ptr == pr->limit) {
/* we're on the last block; unpad if necessary */
int pad;
if (state->use_padding) {
/* we are using RFC 1423-style padding, so the last byte of the
plaintext gives the number of bytes to discard */
pad = temp[15];
if (pad < 1 || pad > 16) {
/* Bug 692343 - don't error here, just warn. Take padding to be
* zero. This may give us a stream that's too long - preferable
* to the alternatives. */
gs_warn1("invalid aes padding byte (0x%02x)",
(unsigned char)pad);
pad = 0;
}
} else {
/* not using padding */
pad = 0;
}
memcpy(pw->ptr + 1, temp, 16 - pad);
pw->ptr += 16 - pad;
return EOFC;
}
memcpy(pw->ptr + 1, temp, 16);
pw->ptr += 16;
}
/* if we got to the end of the file without triggering the padding
check, the input must not have been a multiple of 16 bytes long.
complain. */
if (status == EOFC) {
gs_throw(gs_error_rangecheck, "aes stream isn't a multiple of 16 bytes");
return 0;
}
return status;
}
