// Reference point (Photoshop 6.0)
psd_static psd_status psd_get_layer_reference_point(psd_context * context, psd_layer_record * layer)
{
// 2 double values for the reference point
layer->reference_point_x = (psd_int)psd_stream_get_double(context);
layer->reference_point_y = (psd_int)psd_stream_get_double(context);
return psd_status_done;
}
psd_status psd_get_layer_gradient_overlay2(psd_context * context, psd_layer_effects_gradient_overlay * gradient_overlay)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_gradient_overlay_default(gradient_overlay);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
psd_assert(length == 0);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
// effect enable
case 'enab':
psd_assert(type == 'bool');
gradient_overlay->effect_enable = psd_stream_get_bool(context);
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// blend mode
psd_assert(key == 'BlnM');
gradient_overlay->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
gradient_overlay->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// gradient color
case 'Grad':
// Descriptor
psd_assert(type == 'Objc');
psd_stream_get_object_gradient_color(&gradient_overlay->gradient_color, context);
break;
case 'Angl': // angle
// Unit psd_float
psd_assert(type == 'UntF');
// '#Ang' = angle: base degrees
key = psd_stream_get_int(context);
psd_assert(key == '#Ang');
// Actual value (double)
gradient_overlay->angle = (psd_int)psd_stream_get_double(context);
break;
case 'Type': // gradient style
// Enumerated
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// Gradient Type
psd_assert(key == 'GrdT');
gradient_overlay->style = psd_stream_get_object_gradient_style(context);
break;
case 'Rvrs': // reverse
// boolean
psd_assert(type == 'bool');
gradient_overlay->reverse = psd_stream_get_bool(context);
break;
case 'Algn': // align with layer
// boolean
psd_assert(type == 'bool');
gradient_overlay->align_width_layer = psd_stream_get_bool(context);
break;
case 'Scl ': // scale
// Unit psd_float
psd_assert(type == 'UntF');
// '#Prc' = percent:
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
gradient_overlay->scale = (psd_int)psd_stream_get_double(context);
break;
// offset, not documented
case 'Ofst':
psd_assert(type == 'Objc');
psd_stream_get_object_point(&gradient_overlay->horz_offset,
&gradient_overlay->vert_offset, context);
break;
default:
psd_assert(0);
psd_stream_get_object_null(type, context);
break;
}
}
return psd_status_done;
}
psd_status psd_get_layer_drop_shadow2(psd_context * context, psd_layer_effects_drop_shadow * drop_shadow)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_drop_shadow_default(drop_shadow);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
case 0:
// layer knocks out drop shadow
if(strcmp(keychar, "layerConceals") == 0)
{
psd_assert(type == 'bool');
drop_shadow->knocks_out = psd_stream_get_bool(context);
}
else
{
psd_assert(0);
}
break;
// effect enable
case 'enab':
psd_assert(type == 'bool');
drop_shadow->effect_enable = psd_stream_get_bool(context);
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// blend mode
psd_assert(key == 'BlnM');
drop_shadow->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// color or native color
case 'Clr ':
// Descriptor
psd_assert(type == 'Objc');
drop_shadow->color = drop_shadow->native_color = psd_stream_get_object_color(context);
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
drop_shadow->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// use global light
case 'uglg':
psd_assert(type == 'bool');
drop_shadow->use_global_light = psd_stream_get_bool(context);
break;
// angle
case 'lagl':
psd_assert(type == 'UntF');
// angle: base degrees
key = psd_stream_get_int(context);
psd_assert(key == '#Ang');
drop_shadow->angle = (psd_int)psd_stream_get_double(context);
break;
// distance
case 'Dstn':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
drop_shadow->distance = (psd_int)psd_stream_get_double(context);
break;
// spread
case 'Ckmt':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
drop_shadow->spread = (psd_int)psd_stream_get_double(context);
break;
// size
case 'blur':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
drop_shadow->size = (psd_int)psd_stream_get_double(context);
break;
// noise
case 'Nose':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
drop_shadow->noise = (psd_int)psd_stream_get_double(context);
break;
// anti-aliased
case 'AntA':
psd_assert(type == 'bool');
drop_shadow->anti_aliased = psd_stream_get_bool(context);
break;
// contour
case 'TrnS':
psd_assert(type == 'Objc');
psd_stream_get_object_contour(drop_shadow->contour_lookup_table, context);
break;
default:
psd_assert(0);
break;
}
}
return psd_status_done;
}
psd_status psd_get_layer_color_overlay2(psd_context * context, psd_layer_effects_color_overlay * color_overlay)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_color_overlay_default(color_overlay);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
psd_assert(length == 0);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
// effect enable
case 'enab':
psd_assert(type == 'bool');
color_overlay->effect_enable = psd_stream_get_bool(context);
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// blend mode
psd_assert(key == 'BlnM');
color_overlay->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
color_overlay->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// color or native color
case 'Clr ':
// Descriptor
psd_assert(type == 'Objc');
color_overlay->color = color_overlay->native_color = psd_stream_get_object_color(context);
break;
default:
psd_assert(0);
break;
}
}
return psd_status_done;
}
psd_status psd_get_layer_stroke2(psd_context * context, psd_layer_effects_stroke * stroke)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_stroke_default(stroke);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
case 0:
if(strcmp(keychar, "phase") == 0)
{
psd_assert(type == 'Objc');
psd_stream_get_object_point(&stroke->pattern_horz_phase,
&stroke->pattern_vert_phase, context);
stroke->pattern_horz_phase = 0;
stroke->pattern_vert_phase = 0;
}
else
{
psd_assert(0);
psd_stream_get_object_null(type, context);
}
break;
// effect enable
case 'enab':
psd_assert(type == 'bool');
stroke->effect_enable = psd_stream_get_bool(context);
break;
// position
case 'Styl':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// fill style
psd_assert(key == 'FStl');
length = psd_stream_get_int(context);
if(length == 0)
key = psd_stream_get_int(context);
else
{
key = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
switch(key)
{
case 'OutF':
stroke->position = psd_stroke_outside;
break;
case 'InsF':
stroke->position = psd_stroke_inside;
break;
case 'CtrF':
stroke->position = psd_stroke_center;
break;
default:
psd_assert(0);
break;
}
break;
// fill type
case 'PntT':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// fill style
psd_assert(key == 'FrFl');
length = psd_stream_get_int(context);
if(length == 0)
key = psd_stream_get_int(context);
else
{
key = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
switch(key)
{
case 'SClr':
stroke->fill_type = psd_fill_solid_color;
break;
case 'GrFl':
stroke->fill_type = psd_fill_gradient;
break;
case 'Ptrn':
stroke->fill_type = psd_fill_pattern;
break;
default:
psd_assert(0);
break;
}
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// blend mode
psd_assert(key == 'BlnM');
stroke->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
stroke->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// size
case 'Sz ':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
stroke->size = (psd_int)psd_stream_get_double(context);
break;
// color
case 'Clr ':
// Descriptor
psd_assert(type == 'Objc');
stroke->fill_color = psd_stream_get_object_color(context);
break;
// gradient color
case 'Grad':
// Descriptor
psd_assert(type == 'Objc');
psd_stream_get_object_gradient_color(&stroke->gradient_color, context);
break;
case 'Angl': // angle
// Unit psd_float
psd_assert(type == 'UntF');
// '#Ang' = angle: base degrees
key = psd_stream_get_int(context);
psd_assert(key == '#Ang');
// Actual value (double)
stroke->gradient_angle = (psd_int)psd_stream_get_double(context);
break;
case 'Type': // gradient style
// Enumerated
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// Gradient Type
psd_assert(key == 'GrdT');
stroke->gradient_style = psd_stream_get_object_gradient_style(context);
break;
case 'Rvrs': // reverse
// boolean
psd_assert(type == 'bool');
stroke->gradient_reverse = psd_stream_get_bool(context);
break;
case 'Scl ': // scale
// Unit psd_float
psd_assert(type == 'UntF');
// '#Prc' = percent:
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
if(stroke->fill_type == psd_fill_gradient)
stroke->gradient_scale = (psd_int)psd_stream_get_double(context);
else if(stroke->fill_type == psd_fill_pattern)
stroke->pattern_scale = (psd_int)psd_stream_get_double(context);
break;
case 'Algn': // align with layer
// boolean
psd_assert(type == 'bool');
stroke->gradient_align = psd_stream_get_bool(context);
break;
// offset, not documented
case 'Ofst':
psd_assert(type == 'Objc');
psd_stream_get_object_point(&stroke->gradient_horz_offset,
&stroke->gradient_vert_offset, context);
break;
// pattern
case 'Ptrn':
psd_assert(type == 'Objc');
psd_stream_get_object_pattern_info(&stroke->pattern_info, context);
break;
// link with layer
case 'Lnkd':
psd_assert(type == 'bool');
stroke->pattern_link = psd_stream_get_bool(context);
break;
default:
psd_assert(0);
psd_stream_get_object_null(type, context);
break;
}
}
return psd_status_done;
}
psd_status psd_get_layer_inner_glow2(psd_context * context, psd_layer_effects_inner_glow * inner_glow)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_inner_glow_default(inner_glow);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
psd_assert(length == 0);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
// effect enable
case 'enab':
psd_assert(type == 'bool');
inner_glow->effect_enable = psd_stream_get_bool(context);
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// blend mode
psd_assert(key == 'BlnM');
inner_glow->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// color or native color
case 'Clr ':
// Descriptor
psd_assert(type == 'Objc');
inner_glow->color = inner_glow->native_color = psd_stream_get_object_color(context);
inner_glow->fill_type = psd_fill_solid_color;
break;
// gradient color
case 'Grad':
// Descriptor
psd_assert(type == 'Objc');
psd_stream_get_object_gradient_color(&inner_glow->gradient_color, context);
inner_glow->fill_type = psd_fill_gradient;
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
inner_glow->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// technique
case 'GlwT':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// Matte Technique
psd_assert(key == 'BETE');
inner_glow->technique = psd_stream_get_object_technique(context);
break;
// choke
case 'Ckmt':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
inner_glow->choke = (psd_int)psd_stream_get_double(context);
break;
// size
case 'blur':
psd_assert(type == 'UntF');
// pixels: tagged unit value
key = psd_stream_get_int(context);
psd_assert(key == '#Pxl');
inner_glow->size = (psd_int)psd_stream_get_double(context);
break;
// jitter
case 'ShdN':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
inner_glow->jitter = (psd_int)psd_stream_get_double(context);
break;
// noise
case 'Nose':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
inner_glow->noise = (psd_int)psd_stream_get_double(context);
break;
// anti-aliased
case 'AntA':
psd_assert(type == 'bool');
inner_glow->anti_aliased = psd_stream_get_bool(context);
break;
// source
case 'glwS':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// inner glow source
psd_assert(key == 'IGSr');
length = psd_stream_get_int(context);
if(length == 0)
key = psd_stream_get_int(context);
else
{
key = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
switch(key)
{
case 'SrcC':
inner_glow->source = psd_glow_center;
break;
case 'SrcE':
inner_glow->source = psd_glow_edge;
break;
default:
psd_assert(0);
break;
}
break;
// contour
case 'TrnS':
psd_assert(type == 'Objc');
psd_stream_get_object_contour(inner_glow->contour_lookup_table, context);
break;
// range
case 'Inpr':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
inner_glow->range = (psd_int)psd_stream_get_double(context);
break;
default:
psd_assert(0);
psd_stream_get_object_null(type, context);
break;
}
}
return psd_status_done;
}
// Type Tool Info (Photoshop 5.0 and 5.5 only)
psd_status psd_get_layer_type_tool(psd_context * context, psd_layer_record * layer)
{
psd_layer_type_tool * data;
psd_int i, j, length;
layer->layer_info_type[layer->layer_info_count] = psd_layer_info_type_type_tool;
data = (psd_layer_type_tool *)psd_malloc(sizeof(psd_layer_type_tool));
if(data == NULL)
return psd_status_malloc_failed;
memset(data, 0, sizeof(psd_layer_type_tool));
layer->layer_info_data[layer->layer_info_count] = (psd_uint)data;
layer->layer_info_count ++;
// Version ( = 1)
psd_assert(psd_stream_get_short(context) == 1);
// 6 * 8 double precision numbers for the transform information
for(i = 0; i < 6; i ++)
data->transform_info[i] = psd_stream_get_double(context);
/***********************************************************************/
// Font information
/***********************************************************************/
// Version ( = 6)
psd_assert(psd_stream_get_short(context) == 6);
// Count of faces
data->faces_count = psd_stream_get_short(context);
data->face = (psd_layer_type_face *)psd_malloc(data->faces_count * sizeof(psd_layer_type_face));
if(data->face == NULL)
return psd_status_malloc_failed;
memset(data->face, 0, data->faces_count * sizeof(psd_layer_type_face));
// The next 8 fields are repeated for each count specified above
for(i = 0; i < data->faces_count; i ++)
{
// Mark value
data->face[i].mark = psd_stream_get_short(context);
// Font type data
data->face[i].font_type = psd_stream_get_int(context);
// Pascal string of font name
length = psd_stream_get_char(context);
psd_stream_get(context, data->face[i].font_name, length);
// Pascal string of font family name
length = psd_stream_get_char(context);
psd_stream_get(context, data->face[i].font_family_name, length);
// Pascal string of font style name
length = psd_stream_get_char(context);
psd_stream_get(context, data->face[i].font_style_name, length);
// Script value
data->face[i].script = psd_stream_get_short(context);
// Number of design axes vector to follow
data->face[i].number_axes_vector = psd_stream_get_int(context);
data->face[i].vector = (psd_int *)psd_malloc(data->face[i].number_axes_vector * 4);
if(data->face[i].vector == NULL)
return psd_status_malloc_failed;
// Design vector value
for(j = 0; j < data->face[i].number_axes_vector; j ++)
data->face[i].vector[j] = psd_stream_get_int(context);
}
/***********************************************************************/
// Style information
/***********************************************************************/
// Count of styles
data->styles_count = psd_stream_get_short(context);
data->style = (psd_layer_type_style *)psd_malloc(data->styles_count * sizeof(psd_layer_type_style));
if(data->style == NULL)
return psd_status_malloc_failed;
memset(data->style, 0, data->styles_count * sizeof(psd_layer_type_style));
// The next 10 fields are repeated for each count specified above
for(i = 0; i < data->styles_count; i ++)
{
// Mark value
data->style[i].mark = psd_stream_get_short(context);
// Face mark value
data->style[i].face_mark = psd_stream_get_short(context);
// Size value
data->style[i].size = psd_stream_get_int(context);
// Tracking value
data->style[i].tracking = psd_stream_get_int(context);
// Kerning value
data->style[i].kerning = psd_stream_get_int(context);
// Leading value
data->style[i].leading = psd_stream_get_int(context);
// Base shift value
data->style[i].base_shift = psd_stream_get_int(context);
// Auto kern on/off
data->style[i].auto_kern = psd_stream_get_bool(context);
// Only present in version <= 5
psd_stream_get_char(context);
// Rotate up/down
data->style[i].rotate = psd_stream_get_bool(context);
}
/***********************************************************************/
// Text information
/***********************************************************************/
// Type value
data->type = psd_stream_get_short(context);
// Scaling factor value
data->scaling_factor = psd_stream_get_int(context);
// Sharacter count value
data->sharacter_count = psd_stream_get_int(context);
// Horizontal placement
data->horz_place = psd_stream_get_int(context);
// Vertical placement
data->vert_place = psd_stream_get_int(context);
// Select start value
data->select_start = psd_stream_get_int(context);
// Select end value
data->select_end = psd_stream_get_int(context);
// Line count
data->lines_count = psd_stream_get_short(context);
data->line = (psd_layer_type_line *)psd_malloc(data->lines_count * sizeof(psd_layer_type_line));
if(data->line == NULL)
return psd_status_malloc_failed;
memset(data->line, 0, data->lines_count * sizeof(psd_layer_type_line));
// The next 5 fields are repeated for each item in line count.
for(i = 0; i < data->lines_count; i ++)
{
// Character count value
data->line[i].char_count = psd_stream_get_int(context);
// Orientation value
data->line[i].orientation = psd_stream_get_short(context);
// Alignment value
data->line[i].alignment = psd_stream_get_short(context);
// Actual character as a double byte character
data->line[i].actual_char = psd_stream_get_short(context);
// Style value
data->line[i].style = psd_stream_get_short(context);
}
/***********************************************************************/
// Color information
/***********************************************************************/
// Color space value
data->color = psd_stream_get_space_color(context);
// Anti alias on/off
data->anti_alias = psd_stream_get_bool(context);
return psd_status_done;
}
psd_status psd_get_layer_pattern_overlay2(psd_context * context, psd_layer_effects_pattern_overlay * pattern_overlay)
{
psd_int length, number_items;
psd_uint rootkey, type, key;
psd_uchar keychar[256];
psd_set_layer_pattern_overlay_default(pattern_overlay);
// Unicode string: name from classID
length = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, length);
// classID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte classID
length = psd_stream_get_int(context);
if(length == 0)
psd_stream_get_int(context);
else
psd_stream_get_null(context, length);
// Number of items in descriptor
number_items = psd_stream_get_int(context);
while(number_items --)
{
length = psd_stream_get_int(context);
if(length == 0)
rootkey = psd_stream_get_int(context);
else
{
rootkey = 0;
psd_stream_get(context, keychar, length);
keychar[length] = 0;
}
// Type: OSType key
type = psd_stream_get_int(context);
switch(rootkey)
{
case 0:
if(strcmp(keychar, "phase") == 0)
{
psd_assert(type == 'Objc');
psd_stream_get_object_point(&pattern_overlay->horz_phase,
&pattern_overlay->vert_phase, context);
// problem, why ???
pattern_overlay->horz_phase = 0;
pattern_overlay->vert_phase = 0;
}
else
{
psd_assert(0);
psd_stream_get_object_null(type, context);
}
break;
// effect enable
case 'enab':
psd_assert(type == 'bool');
pattern_overlay->effect_enable = psd_stream_get_bool(context);
break;
// blend mode
case 'Md ':
psd_assert(type == 'enum');
// TypeID: 4 bytes (length), followed either by string or (if length is zero) 4-
// byte typeID
length = psd_stream_get_int(context);
psd_assert(length == 0);
key = psd_stream_get_int(context);
// Gradient Type
psd_assert(key == 'BlnM');
pattern_overlay->blend_mode = psd_stream_get_object_blend_mode(context);
break;
// opacity
case 'Opct':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
pattern_overlay->opacity = (psd_int)(psd_stream_get_double(context) * 2.55 + 0.5);
break;
// pattern
case 'Ptrn':
psd_assert(type == 'Objc');
psd_stream_get_object_pattern_info(&pattern_overlay->pattern_info, context);
break;
// scale
case 'Scl ':
psd_assert(type == 'UntF');
// percent
key = psd_stream_get_int(context);
psd_assert(key == '#Prc');
// Actual value (double)
pattern_overlay->scale = (psd_int)psd_stream_get_double(context);
break;
// link with layer
case 'Algn':
psd_assert(type == 'bool');
pattern_overlay->link_with_layer = psd_stream_get_bool(context);
break;
default:
psd_assert(0);
psd_stream_get_object_null(type, context);
break;
}
}
return psd_status_done;
}
psd_status psd_get_image_resource(psd_context * context)
{
psd_int length, i, size;
psd_ushort ID;
psd_uint tag;
psd_uchar sizeofname;
psd_int sizeofdata, prev_stream_pos;
psd_uchar * buffer;
//psd_status status;
// Length of image resource section
length = psd_stream_get_int(context);
if(length <= 0)
return psd_status_done;
// default
context->global_angle = 30;
context->global_altitude = 30;
while(length > 0)
{
// Signature: '8BIM'
tag = psd_stream_get_int(context);
if(tag == '8BIM')
{
length -= 4;
// Unique identifier for the resource
ID = psd_stream_get_short(context);
length -= 2;
// Name: Pascal string, padded to make the size even (a null name consists of two bytes of 0)
sizeofname = psd_stream_get_char(context);
if((sizeofname & 0x01) == 0)
sizeofname ++;
psd_stream_get_null(context, sizeofname);
length -= sizeofname + 1;
// Actual size of resource data that follows
sizeofdata = psd_stream_get_int(context);
length -= 4;
// resource data must be even
if(sizeofdata & 0x01)
sizeofdata ++;
length -= sizeofdata;
switch(context->load_tag)
{
case psd_load_tag_thumbnail:
if(ID != 1033 && ID != 1036)
{
psd_stream_get_null(context, sizeofdata);
continue;
}
break;
case psd_load_tag_merged:
// alpha channels information
if(ID != 1006 && ID != 1045 && ID != 1053)
{
psd_stream_get_null(context, sizeofdata);
continue;
}
break;
case psd_load_tag_exif:
if(ID != 1058 && ID != 1059)
{
psd_stream_get_null(context, sizeofdata);
continue;
}
break;
}
prev_stream_pos = context->stream.current_pos;
if(sizeofdata > 0)
{
switch(ID)
{
// ResolutionInfo structure
case 1005:
// Horizontal resolution in pixels per inch.
context->resolution_info.hres = psd_stream_get_int(context) / 65536.0f;
// 1=display horitzontal resolution in pixels per inch; 2=display horitzontal resolution in pixels per cm.
context->resolution_info.hres_unit = psd_stream_get_short(context);
// Display width as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
context->resolution_info.width_unit = psd_stream_get_short(context);
// Vertial resolution in pixels per inch.
context->resolution_info.vres = psd_stream_get_int(context) / 65536.0f;
// 1=display vertical resolution in pixels per inch; 2=display vertical resolution in pixels per cm.
context->resolution_info.vres_unit = psd_stream_get_short(context);
// Display height as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
context->resolution_info.height_unit = psd_stream_get_short(context);
context->fill_resolution_info = psd_true;
break;
// Names of the alpha channels as a series of Pascal strings.
case 1006:
buffer = (psd_uchar *)psd_malloc(sizeofdata);
if(buffer == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, buffer, sizeofdata);
if(context->alpha_channels == 0)
{
size = 0;
// maybe odd
while(size + 1 < sizeofdata)
{
size += *(buffer + size) + 1;
context->alpha_channels ++;
}
context->color_channels = context->channels - context->alpha_channels;
context->alpha_channel_info = (psd_alpha_channel_info *)psd_malloc(context->alpha_channels * sizeof(psd_alpha_channel_info));
if(context->alpha_channel_info == NULL)
{
psd_free(buffer);
return psd_status_malloc_failed;
}
memset(context->alpha_channel_info, 0, context->alpha_channels * sizeof(psd_alpha_channel_info));
}
size = 0;
for(i = 0; i < context->alpha_channels; i ++)
{
memcpy(context->alpha_channel_info[i].name, buffer + size + 1, *(buffer + size));
size += *(buffer + size) + 1;
}
psd_free(buffer);
context->fill_alpha_channel_info = psd_true;
break;
// DisplayInfo structure
case 1007:
context->display_info.color = psd_stream_get_space_color(context);
// 0..100
context->display_info.opacity = psd_stream_get_short(context);
psd_assert(context->display_info.opacity >= 0 && context->display_info.opacity <= 100);
// selected = 0, protected = 1
context->display_info.kind = psd_stream_get_char(context);
// maybe be 2 when color mode is multichannel
//psd_assert(context->display_info.kind == 0 || context->display_info.kind == 1);
// padding
psd_stream_get_char(context);
context->fill_display_info = psd_true;
break;
// The caption as a Pascal string.
case 1008:
size = psd_stream_get_char(context);
psd_stream_get(context, context->caption, size);
break;
// Layer state information
// 2 bytes containing the index of target layer (0 = bottom layer).
case 1024:
context->target_layer_index = psd_stream_get_short(context);
break;
// Layers group information
// 2 bytes per layer containing a group ID for the dragging groups. Layers in
// a group have the same group ID.
case 1026:
context->layer_group_count = sizeofdata / 2;
context->layer_group_id = (psd_ushort *)psd_malloc(context->layer_group_count * 2);
if(context->layer_group_id == NULL)
return psd_status_malloc_failed;
for(i = 0; i < context->layer_group_count; i ++)
context->layer_group_id[i] = psd_stream_get_short(context);
context->fill_layer_group = psd_true;
break;
// (Photoshop 4.0) Thumbnail resource for Photoshop 4.0 only
case 1033:
// (Photoshop 5.0) Thumbnail resource (supersedes resource 1033)
case 1036:
if(context->load_tag == psd_load_tag_layer)
{
psd_stream_get_null(context, sizeofdata);
continue;
}
// 1 = kJpegRGB . Also supports kRawRGB (0).
context->thumbnail_resource.format = psd_stream_get_int(context);
psd_assert(context->thumbnail_resource.format == 0 || context->thumbnail_resource.format == 1);
// Width of thumbnail in pixels.
context->thumbnail_resource.width = psd_stream_get_int(context);
// Height of thumbnail in pixels.
context->thumbnail_resource.height = psd_stream_get_int(context);
// Padded row bytes = (width * bits per pixel + 31) / 32 * 4.
context->thumbnail_resource.width_bytes = psd_stream_get_int(context);
// Total size = widthbytes * height * planes
context->thumbnail_resource.total_size = psd_stream_get_int(context);
// Used for consistency check.
context->thumbnail_resource.size_after_compression = psd_stream_get_int(context);
context->thumbnail_resource.bits_per_pixel = psd_stream_get_short(context);
// Bits per pixel. = 24
psd_assert(context->thumbnail_resource.bits_per_pixel == 24);
context->thumbnail_resource.number_of_planes = psd_stream_get_short(context);
// Number of planes. = 1
psd_assert(context->thumbnail_resource.number_of_planes == 1);
#ifdef PSD_INCLUDE_LIBJPEG
if(context->thumbnail_resource.format == 0)
{
status = psd_thumbnail_decode_raw(&context->thumbnail_resource.thumbnail_data,
context->thumbnail_resource.size_after_compression, context);
}
else
{
status = psd_thumbnail_decode_jpeg(&context->thumbnail_resource.thumbnail_data,
context->thumbnail_resource.size_after_compression, context);
}
if(status != psd_status_done)
return status;
#else
context->thumbnail_resource.jfif_data = (psd_uchar *)psd_malloc(sizeofdata - 28);
if(context->thumbnail_resource.jfif_data == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, context->thumbnail_resource.jfif_data, sizeofdata - 28);
#endif
context->fill_thumbnail_resource = psd_true;
break;
// (Photoshop 4.0) Copyright flag
// Boolean indicating whether image is copyrighted. Can be set via
// Property suite or by user in File Info...
case 1034:
context->copyright_flag = (psd_bool)psd_stream_get_short(context);
psd_assert(context->copyright_flag == 0 || context->copyright_flag == 1);
break;
// (Photoshop 5.0) Global Angle
// 4 bytes that contain an integer between 0 and 359, which is the global
// lighting angle for effects layer. If not present, assumed to be 30.
case 1037:
context->global_angle = psd_stream_get_int(context);
break;
// (Photoshop 5.0) Effects visible
// 1-byte global flag to show/hide all the effects layer. Only present when
// they are hidden.
case 1042:
context->effects_visible = (psd_bool)psd_stream_get_short(context);
psd_assert(context->effects_visible == 0 || context->effects_visible == 1);
break;
// (Photoshop 5.0) Unicode Alpha Names
// Unicode string (4 bytes length followed by string).
case 1045:
buffer = (psd_uchar *)psd_malloc(sizeofdata);
if(buffer == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, buffer, sizeofdata);
if(context->alpha_channels == 0)
{
size = 0;
while(size < sizeofdata)
{
size += PSD_CHAR_TO_INT(buffer + size) * 2 + 4;
context->alpha_channels ++;
}
context->color_channels = context->channels - context->alpha_channels;
context->alpha_channel_info = (psd_alpha_channel_info *)psd_malloc(context->alpha_channels * sizeof(psd_alpha_channel_info));
if(context->alpha_channel_info == NULL)
{
psd_free(buffer);
return psd_status_malloc_failed;
}
memset(context->alpha_channel_info, 0, context->alpha_channels * sizeof(psd_alpha_channel_info));
}
size = 0;
for(i = 0; i < context->alpha_channels; i ++)
{
context->alpha_channel_info[i].unicode_name_length = PSD_CHAR_TO_INT(buffer + size);
context->alpha_channel_info[i].unicode_name = (psd_ushort *)psd_malloc(2 * context->alpha_channel_info[i].unicode_name_length);
if(context->alpha_channel_info[i].unicode_name == NULL)
{
psd_free(buffer);
return psd_status_malloc_failed;
}
memcpy(context->alpha_channel_info[i].unicode_name, buffer + size + 4, 2 * context->alpha_channel_info[i].unicode_name_length);
size += 2 * context->alpha_channel_info[i].unicode_name_length + 4;
}
psd_free(buffer);
context->fill_alpha_channel_info = psd_true;
break;
// (Photoshop 6.0) Indexed Color Table Count
// 2 bytes for the number of colors in table that are actually defined
case 1046:
context->indexed_color_table_count = psd_stream_get_short(context);
break;
// (Photoshop 6.0) Transparency Index.
// 2 bytes for the index of transparent color, if any.
case 1047:
context->transparency_index = psd_stream_get_short(context);
break;
// (Photoshop 6.0) Global Altitude
// 4 byte entry for altitude
case 1049:
context->global_altitude = psd_stream_get_int(context);
break;
// (Photoshop 6.0) Alpha Identifiers
// 4 bytes of length, followed by 4 bytes each for every alpha identifier.
case 1053:
if(context->alpha_channels == 0)
{
context->alpha_channels = sizeofdata / 4;
context->color_channels = context->channels - context->alpha_channels;
context->alpha_channel_info = (psd_alpha_channel_info *)psd_malloc(context->alpha_channels * sizeof(psd_alpha_channel_info));
if(context->alpha_channel_info == NULL)
return psd_status_malloc_failed;
memset(context->alpha_channel_info, 0, context->alpha_channels * sizeof(psd_alpha_channel_info));
}
for(i = 0; i < context->alpha_channels; i ++)
{
context->alpha_channel_info[i].identifier = psd_stream_get_int(context);
}
context->fill_alpha_channel_info = psd_true;
break;
// (Photoshop 6.0) Version Info
// 4 bytes version, 1 byte hasRealMergedData, Unicode string: writer
// name, Unicode string: reader name, 4 bytes file version.
case 1057:
context->version_info.version = psd_stream_get_int(context);
context->version_info.has_real_merged_data = psd_stream_get_bool(context);
context->version_info.writer_name_length = psd_stream_get_int(context);
context->version_info.writer_name = (psd_ushort *)psd_malloc(2 * context->version_info.writer_name_length);
if(context->version_info.writer_name == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, (psd_uchar *)context->version_info.writer_name, 2 * context->version_info.writer_name_length);
context->version_info.reader_name_length = psd_stream_get_int(context);
context->version_info.reader_name = (psd_ushort *)psd_malloc(2 * context->version_info.reader_name_length);
if(context->version_info.reader_name == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, (psd_uchar *)context->version_info.reader_name, 2 * context->version_info.reader_name_length);
context->version_info.file_version = psd_stream_get_int(context);
context->fill_version_info = psd_true;
break;
// if you don't need the following image resource,
// you can undef this macro in psd_config.h to reduce the parsing time
/////////////////////////////////////////////////////////////////////////////////////////////
#ifdef PSD_GET_ALL_IMAGE_RESOURCE
// Border information
case 1009:
// a fixed number (2 bytes real, 2 bytes fraction) for the border width
context->border_info.border_width = psd_fixed_16_16_tofloat((psd_fixed_16_16)psd_stream_get_int(context));
// 2 bytes for border units (1 = inches, 2 = cm, 3 = points, 4 = picas, 5 = columns).
context->border_info.border_units = (psd_units)psd_stream_get_short(context);
psd_assert(context->border_info.border_units >= psd_units_inches &&
context->border_info.border_units <= psd_units_columns);
context->fill_border_info = psd_true;
break;
// Print flags
// A series of one-byte boolean values (see Page Setup dialog): labels, crop
// marks, color bars, registration marks, negative, flip, interpolate, caption,
// print flags.
case 1011:
context->print_flags.labels = psd_stream_get_bool(context);
context->print_flags.crop_marks = psd_stream_get_bool(context);
context->print_flags.color_bars = psd_stream_get_bool(context);
context->print_flags.registration_marks = psd_stream_get_bool(context);
context->print_flags.negative = psd_stream_get_bool(context);
context->print_flags.flip = psd_stream_get_bool(context);
context->print_flags.interpolate = psd_stream_get_bool(context);
context->print_flags.caption = psd_stream_get_bool(context);
context->print_flags.print_flags = psd_stream_get_bool(context);
context->fill_print_flags = psd_true;
break;
// (Photoshop 4.0) Grid and guides information
case 1032:
// Version ( = 1)
psd_assert(psd_stream_get_int(context) == 1);
// Future implementation of document-specific grids (4 bytes horizontal, 4 bytes vertical).
context->grid_guides.horz_grid = psd_stream_get_int(context);
context->grid_guides.vert_grid = psd_stream_get_int(context);
// Number of guide resource blocks (can be 0).
context->grid_guides.guide_count = psd_stream_get_int(context);
if(context->grid_guides.guide_count > 0)
{
//Location of guide in document coordinates. Since the guide is either vertical or horizontal, this only has to be one component of the coordinate.
context->grid_guides.guide_coordinate = (psd_int *)psd_malloc(context->grid_guides.guide_count * 4);
// Direction of guide. VHSelect is a system type of psd_uchar where 0 = vertical, 1 = horizontal.
context->grid_guides.guide_direction = (psd_uchar *)psd_malloc(context->grid_guides.guide_count);
if(context->grid_guides.guide_coordinate == NULL ||
context->grid_guides.guide_direction == NULL)
{
psd_free(context->grid_guides.guide_coordinate);
context->grid_guides.guide_coordinate = NULL;
psd_free(context->grid_guides.guide_direction);
context->grid_guides.guide_direction = NULL;
return psd_status_malloc_failed;
}
for(i = 0; i < context->grid_guides.guide_count; i ++)
{
context->grid_guides.guide_coordinate[i] = psd_stream_get_int(context);
context->grid_guides.guide_direction[i] = psd_stream_get_char(context);
}
}
context->fill_grid_and_guides_info = psd_true;
break;
// (Photoshop 5.0) Color samplers resource
case 1038:
// Version ( = 1)
psd_assert(psd_stream_get_int(context) == 1);
// Number of color samplers to follow.
context->color_samplers.number_of_color_samplers = psd_stream_get_int(context);
if (context->color_samplers.number_of_color_samplers > 0)
{
context->color_samplers.resource = (psd_color_samplers_resource *)
psd_malloc(sizeof(psd_color_samplers_resource) * context->color_samplers.number_of_color_samplers);
if (context->color_samplers.resource == NULL)
return psd_status_malloc_failed;
for (i = 0; i < context->color_samplers.number_of_color_samplers; i ++)
{
// The vertical and horizontal position of the point (4 bytes each).
context->color_samplers.resource[i].vertical_position = psd_stream_get_int(context);
context->color_samplers.resource[i].horizontal_position = psd_stream_get_int(context);
// Color Space
context->color_samplers.resource[i].color_space = psd_stream_get_short(context);
}
}
context->fill_color_samplers = psd_true;
break;
// (Photoshop 6.0) Slices
case 1050:
// Version ( = 6)
psd_assert(psd_stream_get_int(context) == 6);
// Bounding rectangle for all of the slices: top, left, bottom, right of all the slices
context->slices_resource.bounding_top = psd_stream_get_int(context);
context->slices_resource.bounding_left = psd_stream_get_int(context);
context->slices_resource.bounding_bottom = psd_stream_get_int(context);
context->slices_resource.bounding_right = psd_stream_get_int(context);
// Name of group of slices: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
// Number of slices to follow
context->slices_resource.number_of_slices = psd_stream_get_int(context);
context->slices_resource.slices_resource_block = (psd_slices_resource_block *)psd_malloc(context->slices_resource.number_of_slices * sizeof(psd_slices_resource_block));
if(context->slices_resource.slices_resource_block == NULL)
return psd_status_malloc_failed;
memset(context->slices_resource.slices_resource_block, 0, context->slices_resource.number_of_slices * sizeof(psd_slices_resource_block));
for(i = 0; i < context->slices_resource.number_of_slices; i ++)
{
context->slices_resource.slices_resource_block[i].id = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].group_id = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].origin = psd_stream_get_int(context);
// NOTE: Only present if Origin = 1
if(context->slices_resource.slices_resource_block[i].origin == 1)
context->slices_resource.slices_resource_block[i].associated_layer_id = psd_stream_get_int(context);
// Name: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
context->slices_resource.slices_resource_block[i].type = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].left = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].top = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].right = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].bottom = psd_stream_get_int(context);
// URL: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
// Target: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
// Message: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
// Alt Tag: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
context->slices_resource.slices_resource_block[i].cell_text_is_html = psd_stream_get_char(context);
// Cell text: Unicode string
size = psd_stream_get_int(context) * 2;
psd_stream_get_null(context, size);
context->slices_resource.slices_resource_block[i].horizontal_alignment = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].veritcal_alignment = psd_stream_get_int(context);
context->slices_resource.slices_resource_block[i].color = psd_argb_to_color(psd_stream_get_char(context),
psd_stream_get_char(context), psd_stream_get_char(context), psd_stream_get_char(context));
}
context->fill_slices_resource = psd_true;
break;
// (Photoshop 6.0) URL List
case 1054:
// 4 byte count of URLs
context->url_list.number_of_urls = psd_stream_get_int(context);
if (context->url_list.number_of_urls > 0)
{
context->url_list.items = (psd_url_list_item *)psd_malloc(sizeof(psd_url_list_item) *
context->url_list.number_of_urls);
if (context->url_list.items == NULL)
return psd_status_malloc_failed;
memset(context->url_list.items, 0, sizeof(psd_url_list_item) * context->url_list.number_of_urls);
}
for (i = 0; i < context->url_list.number_of_urls; i ++)
{
// followed by 4 byte long
context->url_list.items[i].tag = psd_stream_get_int(context);
// 4 byte ID
context->url_list.items[i].ID = psd_stream_get_int(context);
// Unicode string for each count.
context->url_list.items[i].name_length = psd_stream_get_int(context);
context->url_list.items[i].name = (psd_ushort *)psd_malloc(2 * context->url_list.items[i].name_length);
if (context->url_list.items[i].name == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, (psd_uchar *)context->url_list.items[i].name,
2 * context->url_list.items[i].name_length);
}
context->fill_url_list = psd_true;
break;
// (Photoshop 7.0) EXIF data 1
case 1058:
// (Photoshop 7.0) EXIF data 3
// http://www.pima.net/standards/it10/PIMA15740/exif.htm
case 1059:
// avoid to get the exif data for twice
psd_assert(context->fill_exif_data == psd_false);
# ifdef PSD_INCLUDDE_LIBEXIF
buffer = (psd_uchar *)psd_malloc(sizeofdata + sizeof(ExifHeader));
if (buffer == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, buffer + sizeof(ExifHeader), sizeofdata);
memcpy(buffer, ExifHeader, sizeof(ExifHeader));
context->exif_data = (psd_uchar *)exif_data_new_from_data(buffer, sizeofdata + sizeof(ExifHeader));
psd_free(buffer);
context->fill_exif_data = psd_true;
# else // ifdef PSD_INCLUDDE_LIBEXIF
context->exif_data = (psd_uchar *)psd_malloc(sizeofdata);
if (context->exif_data == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, context->exif_data, sizeofdata);
context->exif_data_length = sizeofdata;
context->fill_exif_data = psd_true;
# endif // ifdef PSD_INCLUDDE_LIBEXIF
break;
// (Photoshop 7.0) XMP metadata
// File info as XML description
// http://Partners.adobe.com/asn/developer/xmp/main.html
case 1060:
# ifdef PSD_INCLUDE_LIBXML
buffer = (psd_uchar *)psd_malloc(sizeofdata);
if (buffer == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, buffer, sizeofdata);
context->XMP_metadata = (psd_uchar *)xmlParseMemory(buffer, sizeofdata);
psd_free(buffer);
context->fill_XMP_metadata = psd_true;
# else // ifdef PSD_INCLUDE_LIBXML
context->XMP_metadata = (psd_uchar *)psd_malloc(sizeofdata);
if (context->XMP_metadata == NULL)
return psd_status_malloc_failed;
psd_stream_get(context, context->XMP_metadata, sizeofdata);
context->XMP_metadata_length = sizeofdata;
context->fill_XMP_metadata = psd_true;
# endif // ifdef PSD_INCLUDE_LIBXML
break;
// (Photoshop 7.0) Print scale
case 1062:
// 2 bytes style (0 = centered, 1 = size to fit, 2 = user defined).
context->print_scale.style = psd_stream_get_short(context);
psd_assert(context->print_scale.style >= psd_print_centered &&
context->print_scale.style <= psd_print_user_defined);
// 4 bytes x location (floating point).
context->print_scale.x_location = psd_stream_get_float(context);
// 4 bytes y location (floating point).
context->print_scale.y_location = psd_stream_get_float(context);
// 4 bytes scale (floating point)
context->print_scale.scale = psd_stream_get_float(context);
context->fill_print_scale = psd_true;
break;
// (Photoshop CS) Pixel Aspect Ratio
case 1064:
// 4 bytes (version = 1)
psd_assert(psd_stream_get_int(context) == 1);
// 8 bytes double, x / y of a pixel
context->pixel_aspect_ratio = psd_stream_get_double(context);
break;
// Print flags information
case 10000:
// 2 bytes version ( = 1)
psd_assert(psd_stream_get_short(context) == 1);
// 1 byte center crop marks
context->print_flags_info.center_crop = psd_stream_get_bool(context);
// 1 byte ( = 0)
psd_assert(psd_stream_get_char(context) == 0);
// 4 bytes bleed width value
context->print_flags_info.value = psd_stream_get_int(context);
// 2 bytes bleed width scale
context->print_flags_info.scale = psd_stream_get_short(context);
context->fill_print_flags_info = psd_true;
break;
#endif // ifdef PSD_GET_ALL_IMAGE_RESOURCE
/////////////////////////////////////////////////////////////////////////////////////////////
default:
#ifdef PSD_GET_PATH_RESOURCE
// Photoshop stores its paths as resources of type 8BIM, with IDs in the range 2000
// through 2998.
if(ID >= 2000 && ID <= 2998)
{
psd_get_path(context, sizeofdata);
}
// If the file contains a resource of type 8BIM with an ID of 2999, then this resource
// contains a Pascal¨Cstyle string containing the name of the clipping path to use with this
// image when saving it as an EPS file???
else if(ID == 2999)
{
// we don't find any files includes the name of the clipping path.
psd_assert(0);
}
else
#endif // ifdef PSD_GET_PATH_RESOURCE
{
psd_stream_get_null(context, sizeofdata);
}
break;
}
// Filler
psd_stream_get_null(context, prev_stream_pos + sizeofdata - context->stream.current_pos);
}
}
else
{
return psd_status_resource_signature_error;
}
}
return psd_status_done;
}
