internal override IFDHeader ParseBytes(List <byte> bytes, Endianness e, int offset)
{
IFDHeader result = new IFDHeader(typeof(CanonMakerNotesTagCode));
byte[] fieldsNumberBytes = new byte[2];
fieldsNumberBytes[0] = ByteManager.ChopByteArray(bytes.ToArray(), 0, 1)[0];
int fieldsNumber = ByteManager.GetShortValue(fieldsNumberBytes);
int voided = 0;
byte[][] fieldsBytes = exifProcessor.ExtractTagsBytes(ByteManager.ChopByteArray(bytes.ToArray(), 1, fieldsNumber * 12).ToList(), fieldsNumber).ToArray();
foreach (byte[] fieldBytes in fieldsBytes)
{
byte[] orderedBytes = OrderIFDFieldBytes(fieldBytes);
IFDField field = exifProcessor.GetIFDField <CanonMakerNotesTagCode>(orderedBytes, e);
field.Block = IFDHeaderType.MakerNotesHeader;
field.ValueElementsOffset = ByteManager.GetIntValue(field.FieldValueElements);
LoadFieldTextValue <CanonMakerNotesTagCode>(ref field, bytes, offset, offset, e, voided);
result.IFDFields.Add(field);
}
return(result);
}
internal IFDField GetIFDField <T>(byte[] fieldBytes, Endianness e)
{
IFDField result = new IFDField();
byte[] sortedFieldsBytes = SortIFDFieldBytes(e, fieldBytes);
result.FieldCode = ByteManager.GetUIntValue(ByteManager.ChopByteArray(sortedFieldsBytes, 0, 2));
LoadFieldName <T>(ref result);
result.ValueElementType = ByteManager.GetUIntValue(ByteManager.ChopByteArray(sortedFieldsBytes, 2, 2));
result.ValueElementsCount = ByteManager.GetIntValue(ByteManager.ChopByteArray(sortedFieldsBytes, 4, 4));
result.FieldValueElements = ByteManager.ChopByteArray(sortedFieldsBytes, 8, 4);
result.ValueElementsOffset = 0;
TagElementTypeMappingDictionary typesDictionary = TagElementTypeMappingDictionaryFactory.GetMappingDictionary(typeof(T));
if (result.FieldCode > 0 && typesDictionary.ContainsKey(result.ValueElementType))
{
result.IsOffset = (result.ValueElementsCount * typesDictionary[result.ValueElementType].BytesLength > 4);
result.FieldValueElements = ByteManager.ChopByteArray(sortedFieldsBytes, 8, 4);
}
if (result.IsOffset)
{
result.ValueElementsOffset = ByteManager.GetIntValue(result.FieldValueElements);
}
return(result);
}
private void LoadFieldName <T>(ref IFDField result)
{
if (result == null)
{
return;
}
result.FieldName = Enum.GetName(typeof(T), result.FieldCode);
}
internal IFDHeader GetMakerNoteIFDHeader(IFDField makeField, byte[] makerNotesFieldBytes, Endianness e, ImageFile processingFile)
{
IFDHeader result = null;
MakerInfo makerInfo = MakerInfo.GetMakerInfo(makeField);
result = makerInfo.GetMakerNotesHeader(makerNotesFieldBytes, e, processingFile);
return(result);
}
override protected internal async Task ProcessTagsAsync()
{
await Task.Run(() =>
{
ProcessingFile.App1HeaderOffset = exifProcessor.LocateApp1FileMarkIndex(ProcessingFile.FileBytes);
if (ProcessingFile.App1HeaderOffset < 0)
{
return;
}
ProcessingFile.App1 = exifProcessor.ExtractApp1Header(ProcessingFile.FileBytes, ProcessingFile.App1HeaderOffset);
ProcessingFile.App1.TiffHeader = exifProcessor.GetTiffHeader(ProcessingFile.FileBytes, ProcessingFile.TiffHeaderOffset);
ProcessingFile.App1.ZerothHeader = exifProcessor.GetIFDHeader <IFDTagCode>(IFDHeaderType.ZerothIFD, ProcessingFile.FileBytes, ProcessingFile.ZerothHeaderOffset, ProcessingFile.TiffHeaderOffset, ProcessingFile.App1.TiffHeader.ByteOrder);
ProcessingFile.App1.ExifHeader = exifProcessor.GetIFDHeader <IFDTagCode>(IFDHeaderType.ExifIFD, ProcessingFile.FileBytes, ProcessingFile.ExifHeaderOffset, ProcessingFile.TiffHeaderOffset, ProcessingFile.App1.TiffHeader.ByteOrder);
ProcessingFile.App1.InteropHeader = exifProcessor.GetIFDHeader <IFDTagCode>(IFDHeaderType.InteroperatibilityIFD, ProcessingFile.FileBytes, ProcessingFile.InteropHeaderOffset, ProcessingFile.TiffHeaderOffset, ProcessingFile.App1.TiffHeader.ByteOrder);
ProcessingFile.App1.FirstHeader = exifProcessor.GetIFDHeader <IFDTagCode>(IFDHeaderType.FirstIFD, ProcessingFile.FileBytes, ProcessingFile.FirstHeaderOffset, ProcessingFile.TiffHeaderOffset, ProcessingFile.App1.TiffHeader.ByteOrder);
IFDHeader exifHeaderRef = ProcessingFile.App1.ExifHeader;
IFDField makeField = exifProcessor.FindField(ProcessingFile.App1.ZerothHeader.IFDFields, (uint)IFDTagCode.Make);
if (makeField != null)
{
bool processed = exifProcessor.LoadMakerNotesHeader(ref exifHeaderRef, makeField, ProcessingFile.FileBytes, ProcessingFile.App1.TiffHeader.ByteOrder, ProcessingFile);
if (processed)
{
ProcessingFile.App1.ExifHeader.RemoveMarkerNotesIFD();
}
}
Fields = new List <IFDField>();
Fields.AddRange(ProcessingFile.App1.ZerothHeader.IFDFields);
Fields.AddRange(ProcessingFile.App1.ExifHeader.IFDFields);
if (ProcessingFile.App1.InteropHeader != null)
{
Fields.AddRange(ProcessingFile.App1.InteropHeader.IFDFields);
}
if (ProcessingFile.App1.FirstHeader != null)
{
Fields.AddRange(ProcessingFile.App1.FirstHeader.IFDFields);
}
if (ProcessingFile.App1.ExifHeader.MakerHeader != null)
{
Fields.AddRange(ProcessingFile.App1.ExifHeader.MakerHeader.IFDFields);
}
});
}
internal int LoadFieldTextValue <T>(ref IFDField field, List <byte> fileBytes, int fieldDataOffset, int tiffHeaderOffset, Endianness e, int lastBlockByteFileOffset)
{
if (field.FieldCode == (int)CanonMakerNotesTagCode.CameraSettings1)
{
return(GetCameraSettings1TextValue(ref field, fileBytes, fieldDataOffset, tiffHeaderOffset, e, lastBlockByteFileOffset));
}
else
{
return(exifProcessor.LoadFieldTextValue <CanonMakerNotesTagCode>(ref field, fileBytes, fieldDataOffset, tiffHeaderOffset, e, lastBlockByteFileOffset));
}
}
internal IFDField FindFirstField(List <IFDField> fields, params uint[] codes)
{
IFDField result = null;
int i = 0;
while (!(result != null || i == codes.Count()))
{
result = FindField(fields, codes[i++]);
}
return(result);
}
internal IFDField FindField(List <IFDField> fields, uint code)
{
IEnumerable <IFDField> fieldQuery = fields.Where(field => field.FieldCode == code);
IFDField result = null;
if (fieldQuery != null && fieldQuery.Count() > 0)
{
result = fieldQuery.First();
}
return(result);
}
public IFDField GetTiffTag(string filePath, int tagCode)
{
IFDField result = null;
var field = from f in Fields
where f.FieldCode == tagCode
select f;
if (field.Count() == 1)
{
result = field.First();
}
return(result);
}
internal List <IFDField> GetIFDFields <T>(IFDHeaderType block, List <byte> fileBytes, int blockDataOffset, int fieldsCount, int currentBlockTiffHeaderOffset, Endianness e, out int lastBlockByteFileOffset)
{
lastBlockByteFileOffset = 0;
List <IFDField> result = new List <IFDField>();
byte[][] fieldsBytes = ExtractTagsBytes(ByteManager.ChopByteArray(fileBytes.ToArray(), blockDataOffset + 2, fieldsCount * 12).ToList(), fieldsCount).ToArray();
foreach (byte[] fieldBytes in fieldsBytes)
{
IFDField field = GetIFDField <T>(fieldBytes, e);
field.Block = block;
lastBlockByteFileOffset = LoadFieldTextValue <T>(ref field, fileBytes, blockDataOffset, currentBlockTiffHeaderOffset, e, lastBlockByteFileOffset);
result.Add(field);
}
return(result);
}
internal bool LoadMakerNotesHeader(ref IFDHeader exifHeaderRef, IFDField makeField, List <byte> fileBytes, Endianness e, ImageFile processingFile)
{
if (exifHeaderRef == null)
{
return(true);
}
IFDField makerNoteField = FindField(exifHeaderRef.IFDFields, (uint)IFDTagCode.MakerNote);
if (makerNoteField != null)
{
byte[] makerNotesBytes = ByteManager.ChopByteArray(fileBytes.ToArray(), processingFile.TiffHeaderOffset + makerNoteField.ValueElementsOffset, makerNoteField.ValueElementsCount);
exifHeaderRef.MakerHeader = GetMakerNoteIFDHeader(makeField, makerNotesBytes, e, processingFile);
}
return(exifHeaderRef.MakerHeader != null && exifHeaderRef.MakerHeader.IFDFields != null);
}
internal int LoadFieldTextValue <T>(ref IFDField field, List <byte> fileBytes, int fieldDataOffset, int tiffHeaderOffset, Endianness e, int lastBlockByteFileOffset)
{
int result = lastBlockByteFileOffset;
byte[] valueBytes;
TagElementTypeMappingDictionary typeDictionary = TagElementTypeMappingDictionaryFactory.GetMappingDictionary(typeof(T));
if (field.IsOffset)
{
long fixedOffset = 0;
if (field.Block == IFDHeaderType.ExifIFD)
{
fixedOffset = tiffHeaderOffset + (long)field.ValueElementsOffset;
}
else
{
fixedOffset = fieldDataOffset + (long)field.ValueElementsOffset - 8;
}
valueBytes = ByteManager.ChopByteArray(fileBytes.ToArray(), fixedOffset, (int)field.ValueElementsCount * typeDictionary[field.ValueElementType].BytesLength);
if (lastBlockByteFileOffset < fieldDataOffset + (long)field.ValueElementsOffset - 8 + (int)field.ValueElementsCount * typeDictionary[field.ValueElementType].BytesLength)
{
result = fieldDataOffset + field.ValueElementsOffset - 8 + field.ValueElementsCount * typeDictionary[field.ValueElementType].BytesLength;
}
}
else
{
valueBytes = field.FieldValueElements;
}
TagCodeEnumDictionary enumsDictiornary = FieldCodeEnumDictionaryFactory.GetFieldCodeEnumDictionary <T>();
Type enumType = null;
if (enumsDictiornary.ContainsKey(field.FieldCode))
{
enumType = enumsDictiornary[field.FieldCode];
}
field.Text = GetIFDTextValue <T>(enumType, field.ValueElementType, valueBytes);
return(result);
}
internal static MakerInfo GetMakerInfo(IFDField makeField)
{
MakerInfo result = null;
Maker maker = (Maker)Enum.Parse(typeof(Maker), makeField.Text, true);
switch (maker)
{
case Maker.Nikon:
result = new NikonMakerInfo();
break;
case Maker.Canon:
result = new CanonMakerInfo();
break;
}
return(result);
}
private int GetCameraSettings1TextValue(ref IFDField field, List <byte> fileBytes, int fieldDataOffset, int tiffHeaderOffset, Endianness e, int lastBlockByteFileOffset)
{
byte[] valueBytes;
lastBlockByteFileOffset = 0;
long fixedOffset = fieldDataOffset + (long)field.ValueElementsOffset - 8;
valueBytes = ByteManager.ChopByteArray(fileBytes.ToArray(), fixedOffset, 32);
byte[] format = ByteManager.ChopByteArray(valueBytes, 0, 2);
StringBuilder strBldr = new StringBuilder();
strBldr.AppendFormat("Macro Mode: {0}; ", Enum.ToObject(typeof(CanonMakerInfoCammeraSettings1MacroMode), ByteManager.GetIntValue(format)));
byte[] quality = ByteManager.ChopByteArray(valueBytes, 3, 2);
strBldr.AppendFormat("Quality: {0}; ", Enum.ToObject(typeof(CanonMakerInfoCammeraSettings1Quality), ByteManager.GetIntValue(quality)));
field.Text = strBldr.ToString();
return(0);
}
internal IFDHeader GetIFDHeader <T>(IFDHeaderType blockType, List <byte> fileBytes, int blockDataOffset, int tiffHeaderOffset, Endianness e)
{
if ((blockType == IFDHeaderType.InteroperatibilityIFD || blockType == IFDHeaderType.FirstIFD) &&
blockDataOffset == tiffHeaderOffset)
{
return(null);
}
int lastBlockByteFileOffset = 0;
IFDHeader result = new IFDHeader(typeof(T));
byte[] fieldsCountBytes = ByteManager.ChopByteArray(fileBytes.ToArray(), blockDataOffset, 2);
byte[] sortedFieldsCountBytes = SortBytes(e, fieldsCountBytes);
result.FieldsCount = ByteManager.GetIntValue(sortedFieldsCountBytes);
result.IFDFields = GetIFDFields <T>(blockType, fileBytes, blockDataOffset, (int)result.FieldsCount, tiffHeaderOffset, e, out lastBlockByteFileOffset);
if (blockType == IFDHeaderType.ZerothIFD)
{
result.OffsetToNextIFD = lastBlockByteFileOffset - blockDataOffset;
}
else if (blockType == IFDHeaderType.ExifIFD)
{
var query = from f in result.IFDFields where f.FieldCode == (uint)IFDTagCode.InteropOffset select f;
if (query != null && query.Count() > 0)
{
IFDField interopField = query.First();
result.OffsetToNextIFD = ByteManager.GetIntValue(interopField.FieldValueElements);
}
}
byte[] offsetToNextIFDHeader = ByteManager.ChopByteArray(fileBytes.ToArray(), blockDataOffset + 2 + result.FieldsCount * 12, 4);
byte[] sortedOffsetToNextIFDHeader = SortBytes(e, offsetToNextIFDHeader);
int offset = ByteManager.GetIntValue(sortedOffsetToNextIFDHeader);
result.OffsetTo1stIFD = offset;
return(result);
}
internal override IFDHeader ParseBytes(List <byte> bytes, Endianness e, int offsetCorrectionIndex)
{
IFDHeader result = new IFDHeader(typeof(NikonType1MakerNotesTagCode));
byte[] fieldsCountBytes = ByteManager.ChopByteArray(bytes.ToArray(), 8, 2);
byte[] sortedFieldsCountBytes = exifProcessor.SortBytes(e, fieldsCountBytes);
result.FieldsCount = ByteManager.GetIntValue(sortedFieldsCountBytes);
int voided = 0;
byte[][] fieldsBytes = exifProcessor.ExtractTagsBytes(ByteManager.ChopByteArray(bytes.ToArray(), 8 + 2, result.FieldsCount * 12).ToList(), result.FieldsCount).ToArray();
foreach (byte[] fieldBytes in fieldsBytes)
{
IFDField field = exifProcessor.GetIFDField <NikonType1MakerNotesTagCode>(fieldBytes, e);
field.Block = IFDHeaderType.MakerNotesHeader;
exifProcessor.LoadFieldTextValue <NikonType1MakerNotesTagCode>(ref field, bytes, offsetCorrectionIndex, 0, e, voided);
result.IFDFields.Add(field);
}
return(result);
}
internal byte[] GetIFDBytesValue <T>(List <byte> fileBytes, int blockDataOffset, IFDField field, Endianness endianness)
{
byte[] result;
if (field.IsOffset)
{
TagElementTypeMappingDictionary typeMappingDictionary = TagElementTypeMappingDictionaryFactory.GetMappingDictionary(typeof(T));
if (field.Block == IFDHeaderType.ExifIFD)
{
result = ByteManager.ChopByteArray(fileBytes.ToArray(), 18 + (long)field.ValueElementsOffset - 8, (int)field.ValueElementsCount * typeMappingDictionary[field.ValueElementType].BytesLength);
}
else
{
result = ByteManager.ChopByteArray(fileBytes.ToArray(), blockDataOffset + (long)field.ValueElementsOffset - 8, (int)field.ValueElementsCount * typeMappingDictionary[field.ValueElementType].BytesLength);
}
}
else
{
result = field.FieldValueElements;
}
return(result);
}
