public static SosHeader ReadSosHeader(byte[] bytes) { //SOS HEADER UInt32 sosHeaderOffset = RawReader.FindByteValueIndex(bytes, 0xFF, 0xDA); byte[] sosHeaderBytes = RawReader.ReadBytes(bytes, sosHeaderOffset); UInt32 sosHeaderLengthOffset = 2; byte[] sosHeaderLengthBytes = RawReader.ReadBytes(sosHeaderBytes, sosHeaderLengthOffset, 2); UInt16 sosHeaderLength = ConvertHelper.ConvertToUInt16(sosHeaderLengthBytes, true); UInt32 sosHeaderComponentsNumberOffset = 4; byte sosHeaderComponentsNumber = RawReader.ReadByte(sosHeaderBytes, sosHeaderComponentsNumberOffset); SosHeaderComponentInfo[] components = new SosHeaderComponentInfo[sosHeaderComponentsNumber]; UInt32 sosHeaderComponentsOffset = 5; for (byte k = 0; k < sosHeaderComponentsNumber; k++) { SosHeaderComponentInfo componentInfo = RawReader.ReadSosHeaderComponentInfo(sosHeaderBytes, sosHeaderComponentsOffset); components[k] = componentInfo; sosHeaderComponentsOffset += 2; } return(new SosHeader() { Offset = sosHeaderOffset, HeaderLength = sosHeaderLength, Components = components }); }
private static SosHeaderComponentInfo ReadSosHeaderComponentInfo(byte[] bytes, UInt32 offset) { byte[] componentBytes = RawReader.ReadBytes(bytes, offset, 2); HalvedByte halvedByte = new HalvedByte(componentBytes[1]); return(new SosHeaderComponentInfo() { ComponentNumber = componentBytes[0], DCtable = halvedByte.High, ACtable = halvedByte.Low }); }
private static Sof3HeaderComponentInfo ReadSof3HeaderComponentInfo(byte[] bytes, UInt32 offset) { byte[] componentBytes = RawReader.ReadBytes(bytes, offset, 3); HalvedByte halvedByte = new HalvedByte(componentBytes[1]); return(new Sof3HeaderComponentInfo() { ComponentNumber = componentBytes[0], HorizontalSamplingFactor = halvedByte.High, VerticalSamplingFactor = halvedByte.Low, QuantizationTable = componentBytes[2] }); }
public static Sof3Header ReadSof3Header(byte[] bytes) { //SOF3 HEADER UInt32 sof3HeaderOffset = RawReader.FindByteValueIndex(bytes, 0xFF, 0xC3); byte[] sof3HeaderBytes = RawReader.ReadBytes(bytes, sof3HeaderOffset); UInt32 sof3HeaderLengthOffset = 2; byte[] sof3HeaderLengthBytes = RawReader.ReadBytes(sof3HeaderBytes, sof3HeaderLengthOffset, 2); UInt16 sof3HeaderLength = ConvertHelper.ConvertToUInt16(sof3HeaderLengthBytes, true); UInt32 sof3HeaderSamplePrecisionOffset = 4; byte sof3HeaderSamplePrecision = RawReader.ReadByte(sof3HeaderBytes, sof3HeaderSamplePrecisionOffset); UInt32 sof3HeaderLinesNumberOffset = 5; byte[] sof3HeaderLinesNumberBytes = RawReader.ReadBytes(sof3HeaderBytes, sof3HeaderLinesNumberOffset, 2); UInt16 sof3HeaderLinesNumber = ConvertHelper.ConvertToUInt16(sof3HeaderLinesNumberBytes, true); UInt32 sof3HeaderSamplesPerLineNumberOffset = 7; byte[] sof3HeaderSamplesPerLineNumberBytes = RawReader.ReadBytes(sof3HeaderBytes, sof3HeaderSamplesPerLineNumberOffset, 2); UInt16 sof3HeaderSamplesPerLineNumber = ConvertHelper.ConvertToUInt16(sof3HeaderSamplesPerLineNumberBytes, true); UInt32 sof3HeaderImageComponentsPerFrameNumberOffset = 9; byte sof3HeaderImageComponentsPerFrameNumber = RawReader.ReadByte(sof3HeaderBytes, sof3HeaderImageComponentsPerFrameNumberOffset); Sof3HeaderComponentInfo[] components = new Sof3HeaderComponentInfo[sof3HeaderImageComponentsPerFrameNumber]; UInt32 sof3HeaderComponentsOffset = 10; for (byte k = 0; k < sof3HeaderImageComponentsPerFrameNumber; k++) { Sof3HeaderComponentInfo componentInfo = RawReader.ReadSof3HeaderComponentInfo(sof3HeaderBytes, sof3HeaderComponentsOffset); components[k] = componentInfo; sof3HeaderComponentsOffset += 3; } return(new Sof3Header() { Offset = sof3HeaderOffset, HeaderLength = sof3HeaderLength, SamplePrecision = sof3HeaderSamplePrecision, LinesNumber = sof3HeaderLinesNumber, SamplesPerLineNumber = sof3HeaderSamplesPerLineNumber, Components = components }); }
public static UInt16[] ReadUInt16Array(byte[] bytes, UInt32 offset, UInt32 length) { UInt16[] resArray = new UInt16[length]; UInt32 itemSize = sizeof(UInt16); for (UInt32 index = 0; index < length; index++) { byte[] bytesValue = RawReader.ReadBytes(bytes, offset + index * itemSize, itemSize); UInt16 value = ConvertHelper.ConvertToUInt16(bytesValue); resArray[index] = value; } return(resArray); }
public static DhtHeader ReadDhtHeader(byte[] bytes) { UInt32 dhtHeaderOffset = RawReader.FindByteValueIndex(bytes, 0xFF, 0xC4); byte[] dhtHeaderBytes = RawReader.ReadBytes(bytes, dhtHeaderOffset); UInt32 dhtHeaderLengthOffset = 2; byte[] dhtHeaderLengthBytes = RawReader.ReadBytes(dhtHeaderBytes, dhtHeaderLengthOffset, 2); UInt16 dhtHeaderLength = ConvertHelper.ConvertToUInt16(dhtHeaderLengthBytes, true); UInt32 valueHuffmanCodesOffset; UInt32 lengthNumberHuffmanCodesSum = 0; //Huffman table 1 UInt32 dhtHeaderTableIndexOffset = 4; byte dhtHeaderTableIndex; UInt32 tableOffset = dhtHeaderTableIndexOffset + 1; HuffmanTable tableOne = new HuffmanTable(); dhtHeaderTableIndex = RawReader.ReadByte(dhtHeaderBytes, dhtHeaderTableIndexOffset); tableOne.TableClass = (new HalvedByte(dhtHeaderTableIndex)).High; tableOne.TableIndex = (new HalvedByte(dhtHeaderTableIndex)).Low; byte[] lengthNumberHuffmanCodesBytes = RawReader.ReadBytes(dhtHeaderBytes, tableOffset, DhtHeader.LENGTH_NUMBER_HUFFMAN_CODES_COUNT); lengthNumberHuffmanCodesSum = Convert.ToUInt32(lengthNumberHuffmanCodesBytes.Sum(x => x)); valueHuffmanCodesOffset = tableOffset + DhtHeader.LENGTH_NUMBER_HUFFMAN_CODES_COUNT; byte[] valueHuffmanCodesBytes = RawReader.ReadBytes(dhtHeaderBytes, valueHuffmanCodesOffset, lengthNumberHuffmanCodesSum); tableOne.LengthHuffmanCodes = lengthNumberHuffmanCodesBytes; tableOne.ValueHuffmanCodes = valueHuffmanCodesBytes; //Huffman table 2 dhtHeaderTableIndexOffset = valueHuffmanCodesOffset + lengthNumberHuffmanCodesSum; tableOffset = dhtHeaderTableIndexOffset + 1; HuffmanTable tableTwo = new HuffmanTable(); dhtHeaderTableIndex = RawReader.ReadByte(dhtHeaderBytes, dhtHeaderTableIndexOffset); tableTwo.TableClass = (new HalvedByte(dhtHeaderTableIndex)).High; tableTwo.TableIndex = (new HalvedByte(dhtHeaderTableIndex)).Low; lengthNumberHuffmanCodesBytes = RawReader.ReadBytes(dhtHeaderBytes, tableOffset, DhtHeader.LENGTH_NUMBER_HUFFMAN_CODES_COUNT); lengthNumberHuffmanCodesSum = Convert.ToUInt32(lengthNumberHuffmanCodesBytes.Sum(x => x)); valueHuffmanCodesOffset = tableOffset + DhtHeader.LENGTH_NUMBER_HUFFMAN_CODES_COUNT; valueHuffmanCodesBytes = RawReader.ReadBytes(dhtHeaderBytes, valueHuffmanCodesOffset, lengthNumberHuffmanCodesSum); tableTwo.LengthHuffmanCodes = lengthNumberHuffmanCodesBytes; tableTwo.ValueHuffmanCodes = valueHuffmanCodesBytes; return(new DhtHeader() { Offset = dhtHeaderOffset, HeaderLength = dhtHeaderLength, HuffmanTables = new HuffmanTable[] { tableOne, tableTwo } }); }
public static IntegerMatrix ReadImageFromFile(string filePath) { byte[] fileBytes = File.ReadAllBytes(filePath); List <HeaderItemDescriptor> headerItemList = HeaderItemDescriptor.GetHeaderItemDescriptorList(); #region Byte Order //Byte order HeaderItemDescriptor headerItemByteOrder = headerItemList.FirstOrDefault(item => item.Name == HeaderItemDescriptor.ITEM_BYTE_ORDER); byte[] headerItemByteOrderBytes = RawReader.ReadHeaderItem(fileBytes, headerItemByteOrder); #endregion //First IFD HeaderItemDescriptor headerItemFirstIFD = headerItemList.FirstOrDefault(item => item.Name == HeaderItemDescriptor.ITEM_TIFF_OFFSET); byte[] headerItemFirstIFDBytes = RawReader.ReadHeaderItem(fileBytes, headerItemFirstIFD); List <IFD_0_EntryDescriptor> firstIFDEntryDescriptorList = IFD_0_EntryDescriptor.GetEntryDescriptorList(); //Compression int compressionEntryIndex = firstIFDEntryDescriptorList.FindIndex(item => item.Name == IFD_0_EntryDescriptor.COMPRESSION); UInt32 localCompressionOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(compressionEntryIndex)); UInt32 compressionOffset = BitConverter.ToUInt32(headerItemFirstIFDBytes, 0) + localCompressionOffset; ImageFileDirectoryEntry compressionEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, compressionOffset); UInt16 compressionValue = compressionEntry.GetUInt16Value(); //Make int makeEntryIndex = firstIFDEntryDescriptorList.FindIndex(item => item.Name == IFD_0_EntryDescriptor.MAKE); UInt32 localMakeOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(makeEntryIndex)); UInt32 makeOffset = BitConverter.ToUInt32(headerItemFirstIFDBytes, 0) + localMakeOffset; ImageFileDirectoryEntry makeEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, makeOffset); UInt32 makeOffseValue = makeEntry.GetUInt32Value(); byte[] makeBytes = RawReader.ReadBytesUntilEndingZero(fileBytes, makeOffseValue); string makeValue = ConvertHelper.ConvertToString(makeBytes); //Model int modelEntryIndex = firstIFDEntryDescriptorList.FindIndex(item => item.Name == IFD_0_EntryDescriptor.MODEL); UInt32 localModelOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(modelEntryIndex)); UInt32 modelOffset = BitConverter.ToUInt32(headerItemFirstIFDBytes, 0) + localModelOffset; ImageFileDirectoryEntry modelEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, modelOffset); UInt32 modelOffsetValue = modelEntry.GetUInt32Value(); byte[] modelBytes = RawReader.ReadBytesUntilEndingZero(fileBytes, modelOffsetValue); string modelValue = ConvertHelper.ConvertToString(modelBytes); //X Resolution int xResolutionEntryIndex = firstIFDEntryDescriptorList.FindIndex(item => item.Name == IFD_0_EntryDescriptor.X_RESOLUTION); UInt32 localXResolutionOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(xResolutionEntryIndex)); UInt32 xResolutionOffset = BitConverter.ToUInt32(headerItemFirstIFDBytes, 0) + localXResolutionOffset; ImageFileDirectoryEntry xResolutionEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, xResolutionOffset); UInt32 xResolutionOffsetValue = xResolutionEntry.GetUInt32Value(); byte[] xResolutionBytes = RawReader.ReadBytes(fileBytes, xResolutionOffsetValue, 4); UInt32 xResolutionValue = ConvertHelper.ConvertToUInt32(xResolutionBytes); //DateTime int dateTimeEntryIndex = firstIFDEntryDescriptorList.FindIndex(item => item.Name == IFD_0_EntryDescriptor.DATE_TIME); UInt32 localDateTimeOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(dateTimeEntryIndex)); UInt32 dateTimeOffset = BitConverter.ToUInt32(headerItemFirstIFDBytes, 0) + localDateTimeOffset; ImageFileDirectoryEntry dateTimeEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, dateTimeOffset); UInt32 dateTimeOffsetValue = dateTimeEntry.GetUInt32Value(); byte[] dateTimeBytes = RawReader.ReadBytesUntilEndingZero(fileBytes, dateTimeOffsetValue); string dateTimeValue = ConvertHelper.ConvertToString(dateTimeBytes); DateTime dateTimeStruct = DateTime.ParseExact(dateTimeValue, "yyyy:MM:dd HH:mm:ss", CultureInfo.InvariantCulture); //EXIF bytes IFD_0_EntryDescriptor exifEntryDescriptor = firstIFDEntryDescriptorList.Where(item => item.Name == IFD_0_EntryDescriptor.EXIF).FirstOrDefault(); uint exifOffset = RawReader.GetEntryOffsetByTagID(fileBytes, exifEntryDescriptor.TagID); ImageFileDirectoryEntry exifOffsetEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, exifOffset); UInt32 exifOffsetValue = exifOffsetEntry.GetUInt32Value(); byte[] exifBytes = RawReader.ReadBytes(fileBytes, exifOffsetValue); //Makernote bytes List <EXIF_EntryDescriptor> exifEntryDescriptorList = EXIF_EntryDescriptor.GetEntryDescriptorList(); EXIF_EntryDescriptor makerNoteEntryDescriptor = exifEntryDescriptorList.Where(item => item.Name == EXIF_EntryDescriptor.MAKER_NOTE).FirstOrDefault(); uint makerNoteOffset = RawReader.GetEntryOffsetByTagID(fileBytes, makerNoteEntryDescriptor.TagID); ImageFileDirectoryEntry makerNoteOffsetEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, makerNoteOffset); UInt32 makerNoteOffsetValue = makerNoteOffsetEntry.GetUInt32Value(); byte[] makerNoteBytes = RawReader.ReadBytes(fileBytes, makerNoteOffsetValue); //Color Balance List <Makernote_EntryDescriptor> makernoteEntryDescriptorList = Makernote_EntryDescriptor.GetEntryDescriptorList(); Makernote_EntryDescriptor colorBalanceEntryDescriptor = makernoteEntryDescriptorList.Where(item => item.Name == Makernote_EntryDescriptor.COLOR_BALANCE).FirstOrDefault(); uint colorBalanceOffset = RawReader.GetEntryOffsetByTagID(makerNoteBytes, colorBalanceEntryDescriptor.TagID); ImageFileDirectoryEntry colorBalanceEntry = RawReader.ReadImageFileDirectoryEntry(makerNoteBytes, colorBalanceOffset); UInt32 colorBalanceOffsetValue = colorBalanceEntry.GetUInt32Value(); //Raw Data IFD HeaderItemDescriptor headerItemRawIFD = headerItemList.FirstOrDefault(item => item.Name == HeaderItemDescriptor.ITEM_RAW_IFD_OFFSET); byte[] headerItemRawBytes = RawReader.ReadHeaderItem(fileBytes, headerItemRawIFD); List <IFD_3_EntryDescriptor> rawEntryDescriptorList = IFD_3_EntryDescriptor.GetEntryDescriptorList(); //Slices int slicesIndex = rawEntryDescriptorList.FindIndex(item => item.Name == IFD_3_EntryDescriptor.CR2_SLICE); UInt32 slicesOffset = BitConverter.ToUInt32(headerItemRawBytes, 0) + ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(slicesIndex)); ImageFileDirectoryEntry slicesEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, slicesOffset); UInt16[] slices = RawReader.ReadUInt16Array(fileBytes, slicesEntry.GetUInt32Value(), slicesEntry.NumberOfValue); //Headers and compressed raw bytes int rawOffsetEntryIndex = rawEntryDescriptorList.FindIndex(item => item.Name == IFD_3_EntryDescriptor.STRIP_OFFSET); UInt32 localStripOffset = ImageFileDirectory.GetImageFileDirectoryEntryOffset(Convert.ToUInt32(rawOffsetEntryIndex)); UInt32 stripOffset = BitConverter.ToUInt32(headerItemRawBytes, 0) + localStripOffset; ImageFileDirectoryEntry stripOffsetEntry = RawReader.ReadImageFileDirectoryEntry(fileBytes, stripOffset); UInt32 stripOffsetValue = stripOffsetEntry.GetUInt32Value(); byte[] rawBytes = RawReader.ReadBytes(fileBytes, stripOffsetValue); DhtHeader dhtHeader = RawReader.ReadDhtHeader(rawBytes); Sof3Header sof3Header = RawReader.ReadSof3Header(rawBytes); SosHeader sosHeader = RawReader.ReadSosHeader(rawBytes); Dictionary <string, byte> huffmanCodeValueDictionaryOne = dhtHeader.HuffmanTables[0].GetHuffmanCodeValueMap(); Dictionary <string, byte> huffmanCodeValueDictionaryTwo = dhtHeader.HuffmanTables[1].GetHuffmanCodeValueMap(); //SCAN DATA UInt32 scanDataOffset = sosHeader.Offset + sosHeader.HeaderLength + 2; byte[] scanDataBytes = RawReader.ReadBytes(rawBytes, scanDataOffset); return(RawReader.ReadScanData(scanDataBytes, dhtHeader, sof3Header, sosHeader, slices)); }