https://github.com/zepouet/Xee-xCode-4.5/blob/master/XeePhotoshopLoader.m#L108

Skip to content
 
Sign up

  * Why GitHub?
    Features -
      + Mobile -
      + Actions -
      + Codespaces -
      + Packages -
      + Security -
      + Code review -
      + Project management -
      + Integrations -
      + GitHub Sponsors -
      + Customer stories -
      + Security -
  * Team
  * Enterprise
  * Explore
      + Explore GitHub -

    Learn & contribute

      + Topics -
      + Collections -
      + Trending -
      + Learning Lab -
      + Open source guides -

    Connect with others

      + The ReadME Project -
      + Events -
      + Community forum -
      + GitHub Education -
      + GitHub Stars program -
  * Marketplace
  * Pricing
    Plans -
      + Compare plans -
      + Contact Sales -
      + Nonprofit -
      + Education -

[                    ] [search-key]

  *  
    #
    In this repository All GitHub |
    Jump to |

  * No suggested jump to results

  *  
    #
    In this repository All GitHub |
    Jump to |
  *  
    #
    In this user All GitHub |
    Jump to |
  *  
    #
    In this repository All GitHub |
    Jump to |

Sign in Sign up
{{ message }}

zepouet / Xee-xCode-4.5

  * Watch 2
  * Star 34
  * Fork 5

  * Code
  * Issues 1
  * Pull requests 0
  * Actions
  * Projects 0
  * Security
  * Insights

More

  * Code
  * Issues
  * Pull requests
  * Actions
  * Projects
  * Security
  * Insights

Permalink
master

Xee-xCode-4.5/XeePhotoshopLoader.m

Go to file

  * Go to file T
  * Go to line L
  * 
  * Copy path

@zepouet
zepouet initial commit
Latest commit 102e567 Jan 27, 2013 History
1 contributor

Users who have contributed to this file

496 lines (404 sloc) 14.3 KB
Raw Blame
   

 #import "XeePhotoshopLoader.h"
 #import "Xee8BIMParser.h"
 #import "XeePhotoshopLayerParser.h"
 #import "XeeInterleavingHandle.h"
 #import "XeeRawImage.h"
 #import "XeeBitmapRawImage.h"
 #import "XeeIndexedRawImage.h"
 #import <XADMaster/XADRegex.h>
 @implementation XeePhotoshopImage
 +(NSArray *)fileTypes
 {
 return [NSArray arrayWithObjects:@"psd",@"'8BPS'",nil];
 }
 +(BOOL)canOpenFile:(NSString *)name firstBlock:(NSData *)block 
 attributes:(NSDictionary *)attributes
 {
 uint8_t *header=(uint8_t *)[block bytes];
 if([block length]>6&&XeeBEUInt32(header)=='8BPS'&&XeeBEUInt16
 (header+4)==1) return YES;
 return NO;
 }
 -(id)init
 {
 if(self=[super init])
 {
 }
 return self;
 }
 -(void)dealloc
 {
 [super dealloc];
 }
 -(SEL)initLoader
 {
 CSHandle *fh=[self handle];
 [fh skipBytes:12];
 channels=[fh readUInt16BE];
 height=[fh readUInt32BE];
 width=[fh readUInt32BE];
 bitdepth=[fh readUInt16BE];
 mode=[fh readUInt16BE];
 // Colour data section
 uint32_t colourlen=[fh readUInt32BE];
 off_t resourceoffs=[fh offsetInFile]+colourlen;
 XeePalette *pal=nil;
 if(mode==XeePhotoshopIndexedMode&&colourlen>=768)
 {
 pal=[XeePalette palette];
 uint8_t palbuf[768];
 [fh readBytes:768 toBuffer:palbuf];
 for(int i=0;i<256;i++)
 [pal setColourAtIndex:i red:palbuf[i] green:palbuf[i+256] blue:
 palbuf[i+512]];
 }
 // Resources section
 [fh seekToFileOffset:resourceoffs];
 uint32_t resourcelen=[fh readUInt32BE];
 off_t layermaskoffs=[fh offsetInFile]+resourcelen;
 Xee8BIMParser *parser=[[Xee8BIMParser alloc] initWithHandle:fh];
 NSArray *metaprops=[parser propertyArrayWithPhotoshopFirst:YES];
 BOOL hasmerged=[parser hasMergedImage];
 int numcols=[parser numberOfIndexedColours];
 int trans=[parser indexOfTransparentColour];
 if(trans>=0) [pal setTransparent:trans];
 [parser release];
 // Layers section
 [fh seekToFileOffset:layermaskoffs];
 uint32_t layermasklen=[fh readUInt32BE];
 off_t imageoffs=[fh offsetInFile]+layermasklen;
 NSArray *layers=nil;
 BOOL hasalpha=NO;
 uint32_t layerlen=[fh readUInt32BE];
 off_t maskoffs=[fh offsetInFile]+layerlen;
 if(layerlen>0) layers=[XeePhotoshopLayerParser 
 parseLayersFromHandle:fh parentImage:self alphaFlag:&hasalpha];
 [fh seekToFileOffset:maskoffs];
 uint32_t masklen=[fh readUInt32BE];
 [fh skipBytes:masklen];
 while([fh offsetInFile]+12<=imageoffs)
 {
 uint32_t sign=[fh readUInt32BE];
 uint32_t marker=[fh readUInt32BE];
 uint32_t chunklen=[fh readUInt32BE];
 off_t nextchunk=[fh offsetInFile]+((chunklen+3)&~3);
 // At this point, I'd like to take a moment to speak to you about
 the Adobe PSD format.
 // PSD is not a good format. PSD is not even a bad format. Calling
 it such would be an
 // insult to other bad formats, such as PCX or JPEG. No, PSD is an
 abysmal format. Having
 // worked on this code for several weeks now, my hate for PSD has
 grown to a raging fire
 // that burns with the fierce passion of a million suns.
 // If there are two different ways of doing something, PSD will do
 both, in different
 // places. It will then make up three more ways no sane human would
 think of, and do those
 // too. PSD makes inconsistency an art form. Why, for instance, did
 it suddenly decide
 // that *these* particular chunks should be aligned to four bytes,
 and that this alignement
 // should *not* be included in the size? Other chunks in other
 places are either unaligned,
 // or aligned with the alignment included in the size. Here, though,
 it is not included.
 // Either one of these three behaviours would be fine. A sane format
 would pick one. PSD,
 // of course, uses all three, and more.
 // Trying to get data out of a PSD file is like trying to find
 something in the attic of
 // your eccentric old uncle who died in a freak freshwater shark
 attack on his 58th
 // birthday. That last detail may not be important for the purposes
 of the simile, but
 // at this point I am spending a lot of time imagining amusing fates
 for the people
 // responsible for this Rube Goldberg of a file format.
 // Earlier, I tried to get a hold of the latest specs for the PSD
 file format. To do this,
 // I had to apply to them for permission to apply to them to have
 them consider sending
 // me this sacred tome. This would have involved faxing them a copy
 of some document or
 // other, probably signed in blood. I can only imagine that they
 make this process so
 // difficult because they are intensely ashamed of having created
 this abomination. I
 // was naturally not gullible enough to go through with this
 procedure, but if I had done
 // so, I would have printed out every single page of the spec, and
 set them all on fire.
 // Were it within my power, I would gather every single copy of
 those specs, and launch
 // them on a spaceship directly into the sun.
 //
 // PSD is not my favourite file format.
 if(sign!='8BIM') break; // sanity check
 switch(marker)
 {
 case 'Lr16':
 layers=[XeePhotoshopLayerParser parseLayersFromHandle:fh 
 parentImage:self alphaFlag:NULL];
 break;
 case 'Mt16':
 hasalpha=YES;
 break;
 case 'Anno':
 {
 if([fh readUInt16BE]!=2) break;
 if([fh readUInt16BE]!=1) break;
 int numanno=[fh readUInt32BE];
 NSMutableArray *annotations=[NSMutableArray array];
 for(int i=0;i<numanno;i++)
 {
 uint32_t annolen=[fh readUInt32BE];
 off_t nextanno=[fh offsetInFile]+annolen-4;
 if([fh readUInt32BE]=='txtA')
 {
 [fh skipBytes:46];
 int len=[fh readUInt8];
 [fh skipBytes:len+((len&1)^1)];
 len=[fh readUInt8];
 [fh skipBytes:len+((len&1)^1)];
 len=[fh readUInt8];
 NSString *datestr=[[[NSString alloc] initWithData:[fh 
 readDataOfLength:len] encoding:NSISOLatin1StringEncoding] 
 autorelease];
 [fh skipBytes:((len&1)^1)+4];
 NSCalendarDate *date=nil;
 NSArray *matches=[datestr substringsCapturedByPattern:@"^D:([0-9]
 {4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([+-])([0-9]
 {2})'([0-9]{2})'$"];
 if(matches)
 {
 int year=[[matches objectAtIndex:1] intValue];
 int month=[[matches objectAtIndex:2] intValue];
 int day=[[matches objectAtIndex:3] intValue];
 int hour=[[matches objectAtIndex:4] intValue];
 int minute=[[matches objectAtIndex:5] intValue];
 int second=[[matches objectAtIndex:6] intValue];
 int tzmult=[[matches objectAtIndex:7] isEqual:@"-"]?-1:1;
 int tzhour=[[matches objectAtIndex:8] intValue];
 int tzmin=[[matches objectAtIndex:9] intValue];
 NSTimeZone *tz=[NSTimeZone timeZoneForSecondsFromGMT:tzmult*(tzhour*
 60+tzmin)*60];
 date=[NSCalendarDate dateWithYear:year month:month day:day hour:hour
 minute:minute second:second timeZone:tz];
 }
 if([fh readUInt32BE]=='txtC')
 {
 len=[fh readUInt32BE];
 NSData *annodata=[fh readDataOfLength:len];
 const uint8_t *annobytes=[annodata bytes];
 NSString *str;
 if(len>2&&annobytes[0]==0xfe&&annobytes[1]==0xff)
 str=[[[NSString alloc] initWithBytes:annobytes+2 length:len-2
 encoding:CFStringConvertEncodingToNSStringEncoding(
 kCFStringEncodingUTF16BE)] autorelease];
 else str=[[[NSString alloc] initWithData:annodata encoding:
 NSISOLatin1StringEncoding] autorelease];
 [annotations addObjectsFromArray:[XeePropertyItem itemsWithLabel:
 NSLocalizedString(@"Annotation",@"Photoshop annotation property
 title")
 textValue:str]];
 [annotations addObject:[XeePropertyItem itemWithLabel:
 NSLocalizedString(@"Added at",@"Photoshop annotation date property
 title")
 value:date]];
 }
 }
 [fh seekToFileOffset:nextanno];
 }
 if(numanno) [properties addObject:[XeePropertyItem itemWithLabel:
 NSLocalizedString(@"Photoshop annotations",@"Photoshop annotations
 section title")
 value:annotations identifier:@"psanno"]];
 }
 break;
 }
 [fh seekToFileOffset:nextchunk];
 }
 switch(mode)
 {
 case XeePhotoshopBitmapMode: [self setDepthBitmap]; break;
 case XeePhotoshopGreyscaleMode: [self setDepthGrey:bitdepth alpha:
 hasalpha floating:bitdepth==32?YES:NO]; break;
 case XeePhotoshopIndexedMode: [self setDepthIndexed:numcols?numcols:
 1<<bitdepth]; break;
 case XeePhotoshopRGBMode: [self setDepthRGB:bitdepth alpha:hasalpha 
 floating:bitdepth==32?YES:NO]; break;
 case XeePhotoshopCMYKMode: [self setDepthCMYK:bitdepth alpha:
 hasalpha]; break;
 case XeePhotoshopLabMode: [self setDepthLab:bitdepth alpha:
 hasalpha]; break;
 case XeePhotoshopMultichannelMode:
 [self setDepth:
 [NSString stringWithFormat:NSLocalizedString(@"%d bits multichannel"
 ,@"Description for multichannel (Photoshop) images"),bitdepth]
 iconName:@"depth_grey"];
 break;
 case XeePhotoshopDuotoneMode:
 [self setDepth:
 [NSString stringWithFormat:NSLocalizedString(@"%d bits duotone",@"
 Description for duotone (Photoshop) images"),bitdepth]
 iconName:@"depth_rgb"];
 break;
 }
 [properties addObjectsFromArray:metaprops];
 // Image section
 if(hasmerged)
 {
 [fh seekToFileOffset:imageoffs];
 XeeImage *mainimage=nil;
 switch(mode)
 {
 case XeePhotoshopBitmapMode:
 mainimage=[[[XeeBitmapRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:1 alpha:NO]
 width:width height:height] autorelease];
 break;
 case XeePhotoshopIndexedMode:
 mainimage=[[[XeeIndexedRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:1 alpha:NO]
 width:width height:height palette:pal] autorelease];
 break;
 case XeePhotoshopGreyscaleMode:
 case XeePhotoshopDuotoneMode:
 mainimage=[[[XeeRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:1 alpha:hasalpha]
 width:width height:height depth:bitdepth colourSpace:
 XeeGreyRawColourSpace
 flags:XeeBigEndianRawFlag|XeeAlphaPrecomposedRawFlag|(hasalpha?
 XeeAlphaLastRawFlag:0)|(bitdepth==32?XeeFloatingPointRawFlag:0)]
 autorelease];
 break;
 case XeePhotoshopRGBMode:
 mainimage=[[[XeeRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:3 alpha:hasalpha]
 width:width height:height depth:bitdepth colourSpace:
 XeeRGBRawColourSpace
 flags:XeeBigEndianRawFlag|XeeAlphaPrecomposedRawFlag|(hasalpha?
 XeeAlphaLastRawFlag:0)|(bitdepth==32?XeeFloatingPointRawFlag:0)]
 autorelease];
 break;
 case XeePhotoshopCMYKMode:
 mainimage=[[[XeeRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:4 alpha:hasalpha]
 width:width height:height depth:bitdepth colourSpace:
 XeeCMYKRawColourSpace
 flags:XeeBigEndianRawFlag|XeeAlphaPrecomposedRawFlag|(hasalpha?
 XeeAlphaLastRawFlag:0)]
 autorelease];
 [(XeeRawImage *)mainimage setZeroPoint:1 onePoint:0 forChannel:0];
 [(XeeRawImage *)mainimage setZeroPoint:1 onePoint:0 forChannel:1];
 [(XeeRawImage *)mainimage setZeroPoint:1 onePoint:0 forChannel:2];
 [(XeeRawImage *)mainimage setZeroPoint:1 onePoint:0 forChannel:3];
 break;
 case XeePhotoshopLabMode:
 mainimage=[[[XeeRawImage alloc] initWithHandle:[self 
 handleForNumberOfChannels:3 alpha:hasalpha]
 width:width height:height depth:bitdepth colourSpace:
 XeeLabRawColourSpace
 flags:XeeBigEndianRawFlag|XeeAlphaPrecomposedRawFlag|(hasalpha?
 XeeAlphaLastRawFlag:0)]
 autorelease];
 break;
 }
 [self addSubImage:mainimage];
 }
 NSEnumerator *enumerator=[layers objectEnumerator];
 XeePhotoshopLayerParser *layer;
 while(layer=[enumerator nextObject])
 {
 XeeImage *image=[layer image];
 [self addSubImage:image];
 }
 [self setFormat:@"PSD"];
 loadersel=NULL;
 loaderframe=-1;
 return @selector(loadImage);
 }
 -(void)deallocLoader
 {
 }
 -(SEL)loadImage
 {
 int count=[subimages count];
 for(int i=0;i<count;i++)
 {
 [self runLoaderOnSubImage:[subimages objectAtIndex:i]];
 }
 loaded=YES;
 return NULL;
 /*
 if(!loadersel)
 {
 if(loaderframe>=0) [[subimages objectAtIndex:loaderframe]
 deallocLoader];
 loaderframe++;
 if(loaderframe>=[self frames])
 {
 loaded=YES;
 return NULL;
 }
 loadersel=@selector(initLoader);
 }
 loadersel=(SEL)[[subimages objectAtIndex:loaderframe]
 performSelector:loadersel];
 return @selector(loadImage);*/
 }
 -(CSHandle *)handleForNumberOfChannels:(int)requiredchannels alpha:(
 BOOL)alpha;
 {
 int numchannels=requiredchannels+(alpha?1:0);
 if(numchannels>channels) return nil;
 NSMutableArray *array=[NSMutableArray array];
 off_t totalsize=0;
 int bpr=(bitdepth*width+7)/8;
 int compression=[handle readUInt16BE];
 switch(compression)
 {
 case 0:
 for(int i=0;i<numchannels;i++)
 {
 CSFileHandle *fh=[[handle copy] autorelease];
 [fh skipBytes:i*bpr*height];
 [array addObject:fh];
 }
 break;
 case 1:
 for(int i=0;i<numchannels;i++)
 {
 XeePackbitsHandle *ph=[[[XeePackbitsHandle alloc] initWithHandle:
 [[handle copy] autorelease]
 rows:height bytesPerRow:bpr channel:i of:channels previousSize:
 totalsize] autorelease];
 totalsize+=[ph totalSize];
 [array addObject:ph];
 }
 break;
 }
 if(numchannels==1) return [array objectAtIndex:0];
 else return [[[XeeInterleavingHandle alloc] initWithHandles:array 
 elementSize:bitdepth] autorelease];
 }
 -(int)bitDepth { return bitdepth; }
 -(int)mode { return mode; }
 @end
 @implementation XeePackbitsHandle
 -(id)initWithHandle:(CSHandle *)handle rows:(int)numrows bytesPerRow
 :(int)bpr channel:(int)channel of:(int)numchannels previousSize:(
 off_t)prevsize
 {
 if(self=[super initWithHandle:handle])
 {
 rows=numrows;
 bytesperrow=bpr;
 totalsize=0;
 offsets=malloc(sizeof(off_t)*rows);
 off_t firstrow=numchannels*rows*2+prevsize;
 CSInputSkipBytes(input,2*rows*channel);
 //[parent skipBytes:2*rows*channel];
 for(int i=0;i<rows;i++)
 {
 offsets[i]=firstrow+totalsize;
 totalsize+=CSInputNextUInt16BE(input);
 }
 }
 return self;
 }
 -(void)dealloc
 {
 free(offsets);
 [super dealloc];
 }
 -(uint8_t)produceByteAtOffset:(off_t)pos
 {
 if(pos%bytesperrow==0)
 {
 CSInputSeekToBufferOffset(input,offsets[pos/bytesperrow]);
 spanleft=0;
 }
 if(!spanleft)
 {
 uint8_t b=CSInputNextByte(input);
 if(b&0x80)
 {
 spanleft=(b^0xff)+2;
 spanbyte=CSInputNextByte(input);
 literal=NO;
 }
 else
 {
 spanleft=b+1;
 literal=YES;
 }
 }
 spanleft--;
 if(literal) return CSInputNextByte(input);
 else return spanbyte;
 }
 -(off_t)totalSize { return totalsize; }
 @end
 @implementation XeeDeltaHandle
 -(id)initWithHandle:(CSHandle *)handle depth:(int)bitdepth columns:(
 int)columns
 {
 if(self=[super initWithHandle:handle])
 {
 depth=bitdepth;
 cols=columns;
 }
 return self;
 }
 -(uint8_t)produceByteAtOffset:(off_t)pos
 {
 if(depth==16)
 {
 if((pos&1)==0)
 {
 uint16_t val=CSInputNextUInt16BE(input);
 if((pos/2)%cols==0) curr=val;
 else curr+=val;
 return curr>>8;
 }
 else
 {
 return curr&0xff;
 }
 }
 return 0;
 }
 @end

  * Copy lines
  * Copy permalink
  * View git blame
  * Reference in new issue

[                    ] Go
  * (c) 2021 GitHub, Inc.
  * Terms
  * Privacy
  * Security
  * Status
  * Docs

 

  * Contact GitHub
  * Pricing
  * API
  * Training
  * Blog
  * About

You can't perform that action at this time.
You signed in with another tab or window. Reload to refresh your
session. You signed out in another tab or window. Reload to refresh
your session.