public void Write(PsdBinaryWriter writer) { for (int i = 0; i < Values.Length; i++) { writer.Write((UInt16)Values[i]); } }
protected override void WriteData(PsdBinaryWriter writer) { var startPosition = writer.BaseStream.Position; writer.WriteUnicodeString(Name); writer.WritePadding(startPosition, 4); }
/////////////////////////////////////////////////////////////////////////// public void Save(PsdBinaryWriter writer) { Debug.WriteLine("BlendingRanges Save started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write((UInt32)Data.Length); writer.Write(Data); }
protected override void WriteData(PsdBinaryWriter writer) { foreach (var channelName in ChannelNames) { writer.WriteUnicodeString(channelName); } }
protected override void WriteData(PsdBinaryWriter writer) { foreach (var channelName in ChannelNames) { writer.WritePascalString(channelName, 1); } }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write(Version); writer.Write(HasRealMergedData); writer.WriteUnicodeString(ReaderName); writer.WriteUnicodeString(WriterName); writer.Write(FileVersion); }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write((Int32)SectionType); if (BlendModeKey != null) { writer.WriteAsciiChars("8BIM"); writer.WriteAsciiChars(BlendModeKey); if (subtype != null) writer.Write((Int32)Subtype); } }
public PsdBlockLengthWriter(PsdBinaryWriter writer) { this.writer = writer; // Store position so that we can return to it when the length is known. lengthPosition = writer.BaseStream.Position; // Write a sentinel value as a placeholder for the length. writer.Write((UInt32)0xFEEDFEED); // Store the start position of the data block so that we can calculate // its length when we're done writing. startPosition = writer.BaseStream.Position; }
public void Save(PsdBinaryWriter writer) { Debug.WriteLine("Layer Save started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write(Rect); //----------------------------------------------------------------------- writer.Write((short)Channels.Count); foreach (var ch in Channels) { ch.Save(writer); } //----------------------------------------------------------------------- writer.WriteAsciiChars("8BIM"); writer.WriteAsciiChars(BlendModeKey); writer.Write(Opacity); writer.Write(Clipping); writer.Write((byte)flags.Data); //----------------------------------------------------------------------- writer.Write((byte)0); //----------------------------------------------------------------------- using (new PsdBlockLengthWriter(writer)) { Masks.Save(writer); BlendingRangesData.Save(writer); var namePosition = writer.BaseStream.Position; // Legacy layer name is limited to 31 bytes. Unicode layer name // can be much longer. writer.WritePascalString(Name, 4, 31); foreach (LayerInfo info in AdditionalInfo) { info.Save(writer); } } }
/////////////////////////////////////////////////////////////////////////// private void SaveImage(PsdBinaryWriter writer) { Debug.WriteLine("SaveImage started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write((short)this.ImageCompression); if (this.ImageCompression == PhotoshopFile.ImageCompression.Rle) { foreach (var channel in this.BaseLayer.Channels) { writer.Write(channel.RleHeader); } } foreach (var channel in this.BaseLayer.Channels) { writer.Write(channel.Data); } }
internal void SavePixelData(PsdBinaryWriter writer) { Util.DebugMessage(writer.BaseStream, "Save, Begin, Channel image"); writer.Write((short)ImageCompression); if (ImageDataRaw == null) { return; } if (ImageCompression == PhotoshopFile.ImageCompression.Rle) { RleRowLengths.Write(writer, Layer.PsdFile.IsLargeDocument); } writer.Write(ImageDataRaw); Util.DebugMessage(writer.BaseStream, $"Save, End, Channel image, {ID}"); }
public PsdBlockLengthWriter(PsdBinaryWriter writer, bool hasLongLength) { this.writer = writer; this.hasLongLength = hasLongLength; // Store position so that we can return to it when the length is known. lengthPosition = writer.BaseStream.Position; // Write a sentinel value as a placeholder for the length. writer.Write((UInt32)0xFEEDFEED); if (hasLongLength) { writer.Write((UInt32)0xFEEDFEED); } // Store the start position of the data block so that we can calculate // its length when we're done writing. startPosition = writer.BaseStream.Position; }
/////////////////////////////////////////////////////////////////////////// private void SaveLayerAndMaskInfo(PsdBinaryWriter writer) { Debug.WriteLine("SaveLayerAndMaskInfo started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); using (new PsdBlockLengthWriter(writer)) { var startPosition = writer.BaseStream.Position; SaveLayers(writer); SaveGlobalLayerMask(writer); foreach (var info in AdditionalInfo) { info.Save(writer); } writer.WritePadding(startPosition, 2); } }
public void Save(Stream stream, Encoding encoding) { if (BitDepth != 8) { throw new NotImplementedException("Only 8-bit color has been implemented for saving."); } var writer = new PsdBinaryWriter(stream, encoding); writer.AutoFlush = true; PrepareSave(); SaveHeader(writer); SaveColorModeData(writer); SaveImageResources(writer); SaveLayerAndMaskInfo(writer); SaveImage(writer); }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write(Version); writer.Write(xx); writer.Write(xy); writer.Write(yx); writer.Write(yy); writer.Write(tx); writer.Write(ty); writer.Write(TextVersion); writer.Write(TextDescriptorVestion); TextData.WriteData(writer); writer.Write(WarpVersion); writer.Write(WarpDescriptorVestion); WarpData.WriteData(writer); writer.Write(left); writer.Write(top); writer.Write(right); writer.Write(bottom); }
public void Save(PsdBinaryWriter writer) { Debug.WriteLine("LayerInfo.Save started at " + writer.BaseStream.Position); writer.WriteAsciiChars("8BIM"); writer.WriteAsciiChars(Key); var startPosition = writer.BaseStream.Position; using (var lengthWriter = new PsdBlockLengthWriter(writer)) { // Depending on the key, the length may be unpadded, 2-padded, or // 4-padded. Thus, it is up to each implementation of WriteData to // pad the length correctly. WriteData(writer); } // Regardless of how the length is padded, the data is always padded to // a multiple of 4. writer.WritePadding(startPosition, 4); }
private void SaveLayers(PsdBinaryWriter writer) { Debug.WriteLine("SaveLayers started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); using (new PsdBlockLengthWriter(writer)) { var numLayers = (Int16)Layers.Count; if (AbsoluteAlpha) { numLayers = (Int16)(-numLayers); } // Layers section must be empty if the color mode doesn't allow layers. // Photoshop will refuse to load indexed and multichannel images if // there is a nonempty layers section with a layer count of 0. if (numLayers == 0) { return; } var startPosition = writer.BaseStream.Position; writer.Write(numLayers); foreach (var layer in Layers) { layer.Save(writer); } foreach (var layer in Layers) { foreach (var channel in layer.Channels) { channel.SavePixelData(writer); } } // Documentation states that the Layers Info section is even-padded, // but it is actually padded to a multiple of 4. writer.WritePadding(startPosition, 4); } }
public void Save(PsdBinaryWriter writer) { Debug.WriteLine("LayerInfo.Save started at " + writer.BaseStream.Position); writer.WriteAsciiChars("8BIM"); writer.WriteAsciiChars(Key); var startPosition = writer.BaseStream.Position; using (var lengthWriter = new PsdBlockLengthWriter(writer)) { // Depending on the key, the length may be unpadded, 2-padded, or // 4-padded. Thus, it is up to each implementation of WriteData to // pad the length correctly. WriteData(writer); } // Regardless of how the length is padded, the data is always padded to // a multiple of 4. writer.WritePadding(startPosition, 4); }
/////////////////////////////////////////////////////////////////////////// private void SaveHeader(PsdBinaryWriter writer) { Debug.WriteLine("SaveHeader started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); string signature = "8BPS"; writer.WriteAsciiChars(signature); writer.Write(Version); writer.Write(new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, }); writer.Write(ChannelCount); writer.Write(RowCount); writer.Write(ColumnCount); writer.Write((Int16)BitDepth); writer.Write((Int16)ColorMode); }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write(Data); }
protected override void WriteData(PsdBinaryWriter writer) { throw new System.NotImplementedException(); }
public PsdBlockLengthWriter(PsdBinaryWriter writer) : this(writer, false) { }
/////////////////////////////////////////////////////////////////////////// private void SaveGlobalLayerMask(PsdBinaryWriter writer) { writer.Write((UInt32)GlobalLayerMaskData.Length); writer.Write(GlobalLayerMaskData); }
private void SaveColorModeData(PsdBinaryWriter writer) { writer.Write((UInt32)ColorModeData.Length); writer.Write(ColorModeData); }
/////////////////////////////////////////////////////////////////////////// private void SaveImageResources(PsdBinaryWriter writer) { using (new PsdBlockLengthWriter(writer)) { foreach (var imgRes in ImageResources) imgRes.Save(writer); } }
/////////////////////////////////////////////////////////////////////////// private void SaveLayerAndMaskInfo(PsdBinaryWriter writer) { using (new PsdBlockLengthWriter(writer)) { var startPosition = writer.BaseStream.Position; SaveLayers(writer); SaveGlobalLayerMask(writer); foreach (var info in AdditionalInfo) info.Save(writer); writer.WritePadding(startPosition, 2); } }
protected override void WriteData(PsdBinaryWriter writer) { throw new NotImplementedException("LayerTextType not implemented!"); }
public void Save(Stream stream, Encoding encoding) { if (BitDepth != 8) throw new NotImplementedException("Only 8-bit color has been implemented for saving."); var writer = new PsdBinaryWriter(stream, encoding); writer.AutoFlush = true; PrepareSave(); SaveHeader(writer); SaveColorModeData(writer); SaveImageResources(writer); SaveLayerAndMaskInfo(writer); SaveImage(writer); }
/////////////////////////////////////////////////////////////////////////// private void SaveImage(PsdBinaryWriter writer) { writer.Write((short)this.ImageCompression); if (this.ImageCompression == PhotoshopFile.ImageCompression.Rle) { foreach (var channel in this.BaseLayer.Channels) channel.RleRowLengths.Write(writer); } foreach (var channel in this.BaseLayer.Channels) { writer.Write(channel.ImageDataRaw); } }
internal void Save(PsdBinaryWriter writer) { writer.Write(ID); writer.Write(Length); }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write(HDpi.Integer); writer.Write(HDpi.Fraction); writer.Write((Int16)HResDisplayUnit); writer.Write((Int16)WidthDisplayUnit); writer.Write(VDpi.Integer); writer.Write(VDpi.Fraction); writer.Write((Int16)VResDisplayUnit); writer.Write((Int16)HeightDisplayUnit); }
/////////////////////////////////////////////////////////////////////////// private void SaveGlobalLayerMask(PsdBinaryWriter writer) { Debug.WriteLine("SaveGlobalLayerMask started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write((UInt32)GlobalLayerMaskData.Length); writer.Write(GlobalLayerMaskData); }
private void SaveColorModeData(PsdBinaryWriter writer) { Debug.WriteLine("SaveColorModeData started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write((UInt32)ColorModeData.Length); writer.Write(ColorModeData); }
protected override void WriteData(PsdBinaryWriter writer) { PsdFile.SaveLayersData(writer); }
public override void WriteData(PsdBinaryWriter writer) { writer.WriteAsciiChars(Key); writer.WriteUnicodeString(Text); }
/////////////////////////////////////////////////////////////////////////// private void SaveLayerAndMaskInfo(PsdBinaryWriter writer) { Debug.WriteLine("SaveLayerAndMaskInfo started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); using (new PsdBlockLengthWriter(writer)) { var startPosition = writer.BaseStream.Position; SaveLayers(writer); SaveGlobalLayerMask(writer); foreach (var info in AdditionalInfo) info.Save(writer); writer.WritePadding(startPosition, 2); } }
public abstract void WriteData(PsdBinaryWriter writer);
/// <summary> /// Write the data for this image resource. /// </summary> protected abstract void WriteData(PsdBinaryWriter writer);
/////////////////////////////////////////////////////////////////////////// private void SaveHeader(PsdBinaryWriter writer) { string signature = "8BPS"; writer.WriteAsciiChars(signature); writer.Write(Version); writer.Write(new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, }); writer.Write(ChannelCount); writer.Write(RowCount); writer.Write(ColumnCount); writer.Write((Int16)BitDepth); writer.Write((Int16)ColorMode); }
/////////////////////////////////////////////////////////////////////////// private void SaveImageResources(PsdBinaryWriter writer) { Debug.WriteLine("SaveImageResources started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); using (new PsdBlockLengthWriter(writer)) { foreach (var imgRes in ImageResources) imgRes.Save(writer); } }
protected override void WriteData(PsdBinaryWriter writer) { writer.Write(Data); }
/////////////////////////////////////////////////////////////////////////// private void SaveImage(PsdBinaryWriter writer) { Debug.WriteLine("SaveImage started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); writer.Write((short)this.ImageCompression); if (this.ImageCompression == PhotoshopFile.ImageCompression.Rle) { foreach (var channel in this.BaseLayer.Channels) writer.Write(channel.RleHeader); } foreach (var channel in this.BaseLayer.Channels) { writer.Write(channel.Data); } }
private void SaveColorModeData(PsdBinaryWriter writer) { writer.Write((UInt32)ColorModeData.Length); writer.Write(ColorModeData); }
public override void WriteData(PsdBinaryWriter writer) { writer.WriteAsciiChars(Key); writer.Write(Data.Length); writer.Write(Data); }
/////////////////////////////////////////////////////////////////////////// private void SaveGlobalLayerMask(PsdBinaryWriter writer) { writer.Write((UInt32)GlobalLayerMaskData.Length); writer.Write(GlobalLayerMaskData); }
protected abstract void WriteData(PsdBinaryWriter writer);
public void Save(PsdBinaryWriter writer) { writer.Write(Rect); //----------------------------------------------------------------------- writer.Write((short)Channels.Count); foreach (var ch in Channels) ch.Save(writer); //----------------------------------------------------------------------- writer.WriteAsciiChars("8BIM"); writer.WriteAsciiChars(BlendModeKey); writer.Write(Opacity); writer.Write(Clipping); writer.Write((byte)flags.Data); //----------------------------------------------------------------------- writer.Write((byte)0); //----------------------------------------------------------------------- using (new PsdBlockLengthWriter(writer)) { Masks.Save(writer); BlendingRangesData.Save(writer); var namePosition = writer.BaseStream.Position; // Legacy layer name is limited to 31 bytes. Unicode layer name // can be much longer. writer.WritePascalString(Name, 4, 31); foreach (LayerInfo info in AdditionalInfo) { info.Save(writer); } } }
/////////////////////////////////////////////////////////////////////////// public void Save(PsdBinaryWriter writer) { Debug.WriteLine("MaskInfo Save started at " + writer.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); if (LayerMask == null) { writer.Write((UInt32)0); return; } using (new PsdBlockLengthWriter(writer)) { writer.Write(LayerMask.Rect); writer.Write(LayerMask.BackgroundColor); writer.Write((byte)LayerMask.Flags.Data); if (UserMask == null) { // Pad by 2 bytes to make the block length 20 writer.Write((UInt16)0); } else { writer.Write((byte)UserMask.Flags.Data); writer.Write(UserMask.BackgroundColor); writer.Write(UserMask.Rect); } } }
/////////////////////////////////////////////////////////////////////////// public void Save(PsdBinaryWriter writer) { if (LayerMask == null) { writer.Write((UInt32)0); return; } using (new PsdBlockLengthWriter(writer)) { writer.Write(LayerMask.Rect); writer.Write(LayerMask.BackgroundColor); writer.Write((byte)LayerMask.Flags.Data); if (UserMask == null) { // Pad by 2 bytes to make the block length 20 writer.Write((UInt16)0); } else { writer.Write((byte)UserMask.Flags.Data); writer.Write(UserMask.BackgroundColor); writer.Write(UserMask.Rect); } } }
public override void WriteData(PsdBinaryWriter writer) { writer.WriteAsciiChars(Key); writer.Write(Value); }
private void SaveLayers(PsdBinaryWriter writer) { using (new PsdBlockLengthWriter(writer)) { var numLayers = (Int16)Layers.Count; if (AbsoluteAlpha) numLayers = (Int16)(-numLayers); // Layers section must be empty if the color mode doesn't allow layers. // Photoshop will refuse to load indexed and multichannel images if // there is a nonempty layers section with a layer count of 0. if (numLayers == 0) return; var startPosition = writer.BaseStream.Position; writer.Write(numLayers); foreach (var layer in Layers) { layer.Save(writer); } foreach (var layer in Layers) { foreach (var channel in layer.Channels) { channel.SavePixelData(writer); } } // Documentation states that the Layers Info section is even-padded, // but it is actually padded to a multiple of 4. writer.WritePadding(startPosition, 4); } }