GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Summary:

Browse Source 
- Using std::array instead of c arrays
- Methods and functions are now in PascalCase
- Using std::reverse in EndianSwap
- Using little_endian bool variable
- TRUE_ is now TRUE_NORTH
- Added constructors to GPSCoords class
- GetCurrentTimestamp() method
- Added setter for altitude variable
- Minor renamings
This commit is contained in:
Vladyslav Baranovskyi
2024-09-23 22:09:36 +03:00
parent 0fd5b1aec8
commit ed87e1dfdb
2 changed files with 326 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

571
openVulkanoCpp/Image/ExifBuilder.cpp
View File

@@ -5,16 +5,24 @@
*/ */
#include "ExifBuilder.hpp" #include "ExifBuilder.hpp"
#include <array>
#define ARRAY_COUNT(Array) (sizeof(Array) / sizeof(*Array)) #include <algorithm>
#include <bit>
#include <chrono>
#include <ctime>
#include <iterator>
#include <iomanip>
#include <sstream>
namespace namespace
{ {
char EXIF_HEADER_AND_PADDING[] = {'E', 'x', 'i', 'f', 0, 0}; const int EXIF_HEADER_SIZE = 6;
int const EXIF_HEADER_SIZE = ARRAY_COUNT(EXIF_HEADER_AND_PADDING); std::array<char, EXIF_HEADER_SIZE> EXIF_HEADER_AND_PADDING = { 'E', 'x', 'i', 'f', 0, 0 };
char TIFF_HEADER[] = {0x4d, 0x4d, 0, 0x2a}; const int TIFF_HEADER_SIZE = 4;
int const TIFF_HEADER_SIZE = ARRAY_COUNT(TIFF_HEADER); std::array<char, TIFF_HEADER_SIZE> TIFF_HEADER = { 0x4d, 0x4d, 0, 0x2a };
constexpr bool LITTLE_ENDIAN = std::endian::native == std::endian::little;
enum class IFDTag : uint16_t enum class IFDTag : uint16_t
{ {
@@ -22,8 +30,8 @@ namespace
MAKE = 0x010f, MAKE = 0x010f,
MODEL = 0x0110, MODEL = 0x0110,
ORIENTATION = 0x0112, ORIENTATION = 0x0112,
XRESOLUTION = 0x011a, X_RESOLUTION = 0x011a,
YRESOLUTION = 0x011b, Y_RESOLUTION = 0x011b,
RESOLUTION_UNIT = 0x0128, RESOLUTION_UNIT = 0x0128,
SOFTWARE_USED = 0x0131, SOFTWARE_USED = 0x0131,
DATE_TAKEN = 0x0132, DATE_TAKEN = 0x0132,
@@ -40,143 +48,212 @@ namespace
RATIONAL = 5, RATIONAL = 5,
}; };
uint32_t endianSwap(uint32_t Value) uint32_t EndianSwap(uint32_t value)
{ {
uint32_t Result; uint32_t result;
char *Ptr = (char *)&Value; char *ptr = (char *) &value;
char *Out = (char *)&Result; std::reverse(ptr, ptr + 4);
Out[0] = Ptr[3]; result = value;
Out[1] = Ptr[2];
Out[2] = Ptr[1];
Out[3] = Ptr[0];
return Result;
}
uint16_t endianSwap(uint16_t Value)
{
uint16_t Result;
char *Ptr = (char *)&Value;
char *Out = (char *)&Result;
Out[0] = Ptr[1];
Out[1] = Ptr[0];
return Result;
}
int appendU8(std::vector<uint8_t>& array, uint8_t value)
{
int result = array.size();
array.push_back(value);
return result; return result;
} }
int appendU16(std::vector<uint8_t>& array, uint16_t value, bool endianSwap = false) uint16_t EndianSwap(uint16_t value)
{ {
int result = array.size(); uint16_t result;
if(endianSwap) char *ptr = (char *) &value;
value = ::endianSwap(value); std::reverse(ptr, ptr + 2);
result = value;
char *src = (char *)&value; return result;
}
int AppendU8(std::vector<uint8_t>& array, uint8_t value)
{
int offset = array.size();
array.push_back(value);
return offset;
}
int AppendU16(std::vector<uint8_t>& array, uint16_t value)
{
int offset = array.size();
if constexpr (LITTLE_ENDIAN)
{
value = ::EndianSwap(value);
}
char *src = (char *) &value;
array.push_back(src[0]); array.push_back(src[0]);
array.push_back(src[1]); array.push_back(src[1]);
return result; return offset;
} }
int appendU32(std::vector<uint8_t>& array, uint32_t value, bool endianSwap = false) // no endian swap
int AppendU32NES(std::vector<uint8_t>& array, uint32_t value)
{ {
int result = array.size(); int offset = array.size();
if(endianSwap) char *src = (char *) &value;
value = ::endianSwap(value);
char *src = (char *)&value;
array.push_back(src[0]); array.push_back(src[0]);
array.push_back(src[1]); array.push_back(src[1]);
array.push_back(src[2]); array.push_back(src[2]);
array.push_back(src[3]); array.push_back(src[3]);
return result; return offset;
} }
int appendVector(std::vector<uint8_t>& array, std::vector<uint8_t> values) int AppendU32(std::vector<uint8_t>& array, uint32_t value)
{ {
int result = array.size(); int offset = array.size();
for(auto value : values) if constexpr (LITTLE_ENDIAN)
{
value = ::EndianSwap(value);
}
char *src = (char *) &value;
array.push_back(src[0]);
array.push_back(src[1]);
array.push_back(src[2]);
array.push_back(src[3]);
return offset;
}
template<int COUNT>
int AppendVector(std::vector<uint8_t>& array, const std::array<char, COUNT>& values)
{
int offset = array.size();
for (auto value: values)
{ {
array.push_back(value); array.push_back(value);
} }
return result; return offset;
} }
int appendVector(std::vector<uint8_t>& array, char* values, int count) int AppendVector(std::vector<uint8_t>& array, std::vector<uint8_t> values)
{ {
int result = array.size(); int offset = array.size();
for(int i = 0; i < count; ++i) for (auto value: values)
{
array.push_back(value);
}
return offset;
}
int AppendVector(std::vector<uint8_t>& array, char* values, int count)
{
int offset = array.size();
for (int i = 0; i < count; ++i)
{ {
array.push_back(values[i]); array.push_back(values[i]);
} }
return result; return offset;
} }
int appendRational(std::vector<uint8_t>& array, const OpenVulkano::Image::RationalValue& rational, bool endianSwap = false) int AppendRational(std::vector<uint8_t>& array, const OpenVulkano::Image::RationalValue& rational)
{ {
int result = array.size(); int offset = array.size();
appendU32(array, rational.nominator, endianSwap); AppendU32(array, rational.nominator);
appendU32(array, rational.denominator, endianSwap); AppendU32(array, rational.denominator);
return result; return offset;
} }
int appendGPSCoords(std::vector<uint8_t>& array, const OpenVulkano::Image::GPSCoords& coords, bool endianSwap = false) int AppendGPSCoords(std::vector<uint8_t>& array, const OpenVulkano::Image::GPSCoords& coords)
{ {
int result = array.size(); int offset = array.size();
appendU32(array, coords.degrees, endianSwap); AppendU32(array, coords.degrees);
appendU32(array, 1, endianSwap); AppendU32(array, 1);
appendU32(array, coords.minutes, endianSwap); AppendU32(array, coords.minutes);
appendU32(array, 1, endianSwap); AppendU32(array, 1);
appendU32(array, coords.seconds, endianSwap); AppendU32(array, coords.seconds);
appendU32(array, 1, endianSwap); AppendU32(array, 1);
return result; return offset;
}
void AppendTagAndValueType(std::vector<uint8_t>& array, uint16_t tag, uint16_t valueType)
{
AppendU16(array, tag);
AppendU16(array, valueType);
}
void AddValueToU32AndEndianSwap(uint8_t *data, int valueToAdd)
{
uint32_t *ptr = (uint32_t *) data;
*ptr += valueToAdd;
*ptr = EndianSwap(*ptr);
} }
} }
namespace OpenVulkano::Image namespace OpenVulkano::Image
{ {
std::vector<uint8_t> ExifBuilder::build() GPSCoords::GPSCoords(int32_t valueForAll)
{
this->degrees = valueForAll;
this->minutes = valueForAll;
this->seconds = valueForAll;
}
GPSCoords::GPSCoords(int32_t degrees, int32_t minutes, int32_t seconds)
{
this->degrees = degrees;
this->minutes = minutes;
this->seconds = seconds;
}
void ExifBuilder::SetAltitude(float level)
{
altitudeIsAboveSeaLevel = level >= 0;
if (level < 0)
{
level = -level;
}
altitude = level;
}
std::vector<uint8_t> ExifBuilder::Build()
{ {
std::vector<uint8_t> result; std::vector<uint8_t> result;
std::vector<uint8_t> data; // the data that has ascii values std::vector<uint8_t> data; // the data that has ascii and rational values
appendVector(result, EXIF_HEADER_AND_PADDING, EXIF_HEADER_SIZE); if (dateTaken == "")
appendVector(result, TIFF_HEADER, TIFF_HEADER_SIZE); {
dateTaken = GetCurrentTimestamp();
}
AppendVector(result, EXIF_HEADER_AND_PADDING);
AppendVector(result, TIFF_HEADER);
int numberOfMainTags = 1; // 1 is for GPS Info tag int numberOfMainTags = 1; // 1 is for GPS Info tag
numberOfMainTags += orientation != 0; numberOfMainTags += orientation != 0;
numberOfMainTags += make != ""; numberOfMainTags += make != "";
numberOfMainTags += model != ""; numberOfMainTags += model != "";
numberOfMainTags += xresolution.nominator || xresolution.denominator; numberOfMainTags += xResolution.nominator || xResolution.denominator;
numberOfMainTags += yresolution.nominator || yresolution.denominator; numberOfMainTags += yResolution.nominator || yResolution.denominator;
numberOfMainTags += resolutionUnit != 0; numberOfMainTags += resolutionUnit != 0;
numberOfMainTags += exposureTime.nominator || exposureTime.denominator; numberOfMainTags += exposureTime.nominator || exposureTime.denominator;
numberOfMainTags += softwareUsed != ""; numberOfMainTags += softwareUsed != "";
numberOfMainTags += dateTaken != ""; numberOfMainTags += dateTaken != "";
appendU32(result, 8, true); // append offset to the ifd AppendU32(result, 8); // Append offset to the ifd
appendU16(result, numberOfMainTags, true); AppendU16(result, numberOfMainTags);
// offsets in result array where the offset to the data should be stored // offsets in result array where the offset to the data should be stored
int makeOffset = 0; int makeOffset = 0;
@@ -186,96 +263,88 @@ namespace OpenVulkano::Image
int gpsInfoOffset = 0; int gpsInfoOffset = 0;
// Make // Make
if(make != "") if (make != "")
{ {
appendU16(result, (uint16_t)IFDTag::MAKE, true); AppendTagAndValueType(result, (uint16_t) IFDTag::MAKE, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t)IFDValueType::ASCII, true); AppendU32(result, make.size() + 1);
appendU32(result, make.size() + 1, true); makeOffset = AppendU32(result, data.size() + 1);
makeOffset = appendU32(result, data.size() + 1, true); int offsetInData = AppendVector(data, (char *)make.c_str(), make.size() + 1);
int offsetInData = appendVector(data, (char *)make.c_str(), make.size() + 1);
uint32_t* ptr = (uint32_t *)(result.data() + makeOffset); uint32_t* ptr = (uint32_t *)(result.data() + makeOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// Model // Model
if(model != "") if (model != "")
{ {
appendU16(result, (uint16_t)IFDTag::MODEL, true); AppendTagAndValueType(result, (uint16_t) IFDTag::MODEL, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t)IFDValueType::ASCII, true); AppendU32(result, model.size() + 1);
appendU32(result, model.size() + 1, true); modelOffset = AppendU32(result, data.size() + 1);
modelOffset = appendU32(result, data.size() + 1, true); int offsetInData = AppendVector(data, (char *)model.c_str(), model.size() + 1);
int offsetInData = appendVector(data, (char *)model.c_str(), model.size() + 1);
uint32_t* ptr = (uint32_t *)(result.data() + modelOffset); uint32_t* ptr = (uint32_t *)(result.data() + modelOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// Orientation // Orientation
if(orientation != 0) if (orientation != 0)
{ {
appendU16(result, (uint16_t)IFDTag::ORIENTATION, true); AppendTagAndValueType(result, (uint16_t) IFDTag::ORIENTATION, (uint16_t) IFDValueType::SHORT);
appendU16(result, (uint16_t)IFDValueType::SHORT, true); AppendU32(result, 1);
appendU32(result, 1, true); AppendU16(result, (uint16_t)orientation);
appendU16(result, (uint16_t)orientation, true); AppendU16(result, 0); // padding
appendU16(result, 0); // padding
} }
// XResolution // xResolution
int xresolutionOffset = 0; int xResolutionOffset = 0;
if(xresolution.nominator || xresolution.denominator) if (xResolution.nominator || xResolution.denominator)
{ {
appendU16(result, (uint16_t)IFDTag::XRESOLUTION, true); AppendTagAndValueType(result, (uint16_t) IFDTag::X_RESOLUTION, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t)IFDValueType::RATIONAL, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components xResolutionOffset = AppendU32(result, data.size());
xresolutionOffset = appendU32(result, data.size(), true); int offsetInData = AppendRational(data, xResolution);
int offsetInData = appendRational(data, xresolution, true); uint32_t* ptr = (uint32_t *)(result.data() + xResolutionOffset);
uint32_t* ptr = (uint32_t *)(result.data() + xresolutionOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// YResolution // yResolution
int yresolutionOffset = 0; int yResolutionOffset = 0;
if(yresolution.nominator || yresolution.denominator) if (yResolution.nominator || yResolution.denominator)
{ {
appendU16(result, (uint16_t)IFDTag::YRESOLUTION, true); AppendTagAndValueType(result, (uint16_t) IFDTag::Y_RESOLUTION, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t)IFDValueType::RATIONAL, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components yResolutionOffset = AppendU32(result, data.size());
yresolutionOffset = appendU32(result, data.size(), true); int offsetInData = AppendRational(data, yResolution);
int offsetInData = appendRational(data, yresolution, true); uint32_t* ptr = (uint32_t *)(result.data() + yResolutionOffset);
uint32_t* ptr = (uint32_t *)(result.data() + yresolutionOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// Exposure Time // Exposure Time
int exposureTimeOffset = 0; int exposureTimeOffset = 0;
if(exposureTime.nominator || exposureTime.denominator) if (exposureTime.nominator || exposureTime.denominator)
{ {
appendU16(result, (uint16_t)IFDTag::EXPOSURE_TIME, true); AppendTagAndValueType(result, (uint16_t) IFDTag::EXPOSURE_TIME, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t)IFDValueType::RATIONAL, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components exposureTimeOffset = AppendU32(result, data.size());
exposureTimeOffset = appendU32(result, data.size(), true); int offsetInData = AppendRational(data, exposureTime);
int offsetInData = appendRational(data, exposureTime, true);
uint32_t* ptr = (uint32_t *)(result.data() + exposureTimeOffset); uint32_t* ptr = (uint32_t *)(result.data() + exposureTimeOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// ResolutionUnit // ResolutionUnit
if(resolutionUnit != 0) if (resolutionUnit != 0)
{ {
appendU16(result, (uint16_t)IFDTag::RESOLUTION_UNIT, true); AppendTagAndValueType(result, (uint16_t) IFDTag::RESOLUTION_UNIT, (uint16_t) IFDValueType::SHORT);
appendU16(result, (uint16_t)IFDValueType::SHORT, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components AppendU16(result, resolutionUnit);
appendU16(result, resolutionUnit, true); AppendU16(result, 0); // padding
appendU16(result, 0); // padding
} }
// Software Used // Software Used
if(softwareUsed != "") if (softwareUsed != "")
{ {
appendU16(result, (uint16_t)IFDTag::SOFTWARE_USED, true); AppendTagAndValueType(result, (uint16_t) IFDTag::SOFTWARE_USED, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t)IFDValueType::ASCII, true); AppendU32(result, softwareUsed.size() + 1);
appendU32(result, softwareUsed.size() + 1, true); softwareUsedOffset = AppendU32(result, data.size() + 1);
softwareUsedOffset = appendU32(result, data.size() + 1, true); int offsetInData = AppendVector(data, (char *)softwareUsed.c_str(), softwareUsed.size() + 1);
int offsetInData = appendVector(data, (char *)softwareUsed.c_str(), softwareUsed.size() + 1);
uint32_t* ptr = (uint32_t *)(result.data() + softwareUsedOffset); uint32_t* ptr = (uint32_t *)(result.data() + softwareUsedOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
@@ -283,192 +352,174 @@ namespace OpenVulkano::Image
// Date Taken // Date Taken
// NOTE(vb): For some reason windows file properties doesn't print date taken field! // NOTE(vb): For some reason windows file properties doesn't print date taken field!
// Even though other software does provide this information without a problem // Even though other software does provide this information without a problem
if(dateTaken != "")
{ {
appendU16(result, (uint16_t)IFDTag::DATE_TAKEN, true); AppendTagAndValueType(result, (uint16_t) IFDTag::DATE_TAKEN, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t)IFDValueType::ASCII, true); AppendU32(result, dateTaken.size() + 1);
appendU32(result, dateTaken.size() + 1, true); dateTakenOffset = AppendU32(result, data.size() + 1);
dateTakenOffset = appendU32(result, data.size() + 1, true); int offsetInData = AppendVector(data, (char *)dateTaken.c_str(), dateTaken.size() + 1);
int offsetInData = appendVector(data, (char *)dateTaken.c_str(), dateTaken.size() + 1);
uint32_t* ptr = (uint32_t *)(result.data() + dateTakenOffset); uint32_t* ptr = (uint32_t *)(result.data() + dateTakenOffset);
*ptr = offsetInData; *ptr = offsetInData;
} }
// GPS Info offset // GPS Info offset
appendU16(result, (uint16_t) IFDTag::GPS_INFO_OFFSET, true); AppendTagAndValueType(result, (uint16_t) IFDTag::GPS_INFO_OFFSET, (uint16_t) IFDValueType::LONG_);
appendU16(result, (uint16_t) IFDValueType::LONG_, true); AppendU32(result, 1); // num components
appendU32(result, 1, true); // num components gpsInfoOffset = AppendU32(result, 0); // to be filled
gpsInfoOffset = appendU32(result, 0, true); // to be filled
// next ifd offset // next ifd offset
appendU32(result, 0); AppendU32(result, 0);
int resultSize = result.size(); int resultSize = result.size();
appendVector(result, data); AppendVector(result, data);
int ifdAndSubdataSize = result.size(); int ifdAndSubdataSize = result.size();
if(model != "")
{ {
uint32_t *ptr = (uint32_t *) (result.data() + modelOffset); const int valueToAdd = resultSize - EXIF_HEADER_SIZE;
*ptr += resultSize - EXIF_HEADER_SIZE; if (model != "")
*ptr = endianSwap(*ptr); {
} AddValueToU32AndEndianSwap(result.data() + modelOffset, valueToAdd);
}
if(make != "") if (make != "")
{ {
uint32_t *ptr = (uint32_t *) (result.data() + makeOffset); AddValueToU32AndEndianSwap(result.data() + makeOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
if(xresolutionOffset) if (xResolutionOffset)
{ {
uint32_t *ptr = (uint32_t *) (result.data() + xresolutionOffset); AddValueToU32AndEndianSwap(result.data() + xResolutionOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
if(yresolutionOffset) if (yResolutionOffset)
{ {
uint32_t *ptr = (uint32_t *) (result.data() + yresolutionOffset); AddValueToU32AndEndianSwap(result.data() + yResolutionOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
if(exposureTimeOffset) if (exposureTimeOffset)
{ {
uint32_t *ptr = (uint32_t *) (result.data() + exposureTimeOffset); AddValueToU32AndEndianSwap(result.data() + exposureTimeOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
if(dateTakenOffset) if (dateTakenOffset)
{ {
uint32_t *ptr = (uint32_t *) (result.data() + dateTakenOffset); AddValueToU32AndEndianSwap(result.data() + dateTakenOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
if(softwareUsedOffset) if (softwareUsedOffset)
{ {
uint32_t *ptr = (uint32_t *) (result.data() + softwareUsedOffset); AddValueToU32AndEndianSwap(result.data() + softwareUsedOffset, valueToAdd);
*ptr += resultSize - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
} }
{ {
uint32_t *ptr = (uint32_t *) (result.data() + gpsInfoOffset); uint32_t *ptr = (uint32_t *) (result.data() + gpsInfoOffset);
*ptr = endianSwap((uint32_t)(ifdAndSubdataSize - EXIF_HEADER_SIZE)); *ptr = EndianSwap((uint32_t)(ifdAndSubdataSize - EXIF_HEADER_SIZE));
} }
// Writing GPS Info structure // Writing GPS Info structure
int numberOfGPSInfoTags = 8; int numberOfGPSInfoTags = 8;
appendU16(result, numberOfGPSInfoTags, true); AppendU16(result, numberOfGPSInfoTags);
// Latitude Ref // Latitude Ref
appendU16(result, 1, true); AppendTagAndValueType(result, 1, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t) IFDValueType::ASCII, true); AppendU32(result, 2); // 2 for N/S + \0
appendU32(result, 2, true); // 2 for N/S + \0 AppendU8(result, latitudeRef == LatitudeRef::NORTH ? 'N' : 'S');
appendU8(result, latitudeRef == LatitudeRef::NORTH ? 'N' : 'S'); AppendU8(result, 0);
appendU8(result, 0); AppendU8(result, 0); // padding
appendU8(result, 0); // padding AppendU8(result, 0); // padding
appendU8(result, 0); // padding
// Latitude // Latitude
appendU16(result, 2, true); AppendTagAndValueType(result, 2, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t) IFDValueType::RATIONAL, true); AppendU32(result, 3); // number of components
appendU32(result, 3, true); // number of components int latitudeOffset = AppendU32NES(result, 0); // 0 * sizeof(RationalValue)
int latitudeOffset = appendU32(result, 0); // 0 * sizeof(RationalValue)
// Longitude Ref // Longitude Ref
appendU16(result, 3, true); AppendTagAndValueType(result, 3, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t) IFDValueType::ASCII, true); AppendU32(result, 2); // 2 for E/W + \0
appendU32(result, 2, true); // 2 for E/W + \0 AppendU8(result, longitudeRef == LongitudeRef::EAST ? 'E' : 'W');
appendU8(result, longitudeRef == LongitudeRef::EAST ? 'E' : 'W'); AppendU8(result, 0);
appendU8(result, 0); AppendU8(result, 0); // padding
appendU8(result, 0); // padding AppendU8(result, 0); // padding
appendU8(result, 0); // padding
// Longitude // Longitude
appendU16(result, 4, true); AppendTagAndValueType(result, 4, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t) IFDValueType::RATIONAL, true); AppendU32(result, 3); // number of components
appendU32(result, 3, true); // number of components int longitudeOffset = AppendU32NES(result, 24); // 3 * sizeof(RationalValue)
int longitudeOffset = appendU32(result, 24); // 3 * sizeof(RationalValue)
// Altitude Ref // Altitude Ref
appendU16(result, 5, true); AppendTagAndValueType(result, 5, (uint16_t) IFDValueType::BYTE);
appendU16(result, (uint16_t) IFDValueType::BYTE, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components AppendU8(result, altitudeIsAboveSeaLevel ? 0 : 1);
appendU8(result, altitudeIsAboveSeaLevel ? 0 : 1); AppendU8(result, 0); // padding
appendU8(result, 0); // padding AppendU8(result, 0); // padding
appendU8(result, 0); // padding AppendU8(result, 0); // padding
appendU8(result, 0); // padding
// Altitude // Altitude
appendU16(result, 6, true); AppendTagAndValueType(result, 6, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t) IFDValueType::RATIONAL, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components int altitudeOffset = AppendU32NES(result, 48); // 6 * sizeof(RationalValue)
int altitudeOffset = appendU32(result, 48); // 6 * sizeof(RationalValue)
// Track Ref // Track Ref
appendU16(result, 14, true); AppendTagAndValueType(result, 14, (uint16_t) IFDValueType::ASCII);
appendU16(result, (uint16_t) IFDValueType::ASCII, true); AppendU32(result, 2); // 2 for T/M + \0
appendU32(result, 2, true); // 2 for T/M + \0 AppendU8(result, trackRef == GPSTrackRef::TRUE_NORTH ? 'T' : 'M');
appendU8(result, trackRef == GPSTrackRef::TRUE_ ? 'T' : 'M'); AppendU8(result, 0);
appendU8(result, 0); AppendU8(result, 0); // padding
appendU8(result, 0); // padding AppendU8(result, 0); // padding
appendU8(result, 0); // padding
// Track // Track
appendU16(result, 15, true); AppendTagAndValueType(result, 15, (uint16_t) IFDValueType::RATIONAL);
appendU16(result, (uint16_t) IFDValueType::RATIONAL, true); AppendU32(result, 1); // number of components
appendU32(result, 1, true); // number of components int trackOffset = AppendU32NES(result, 56); // 7 * sizeof(RationalValue)
int trackOffset = appendU32(result, 56); // 7 * sizeof(RationalValue)
// //
int sizeOfResultSoFar = result.size();
// Latitude
{ {
uint32_t *ptr = (uint32_t *) (result.data() + latitudeOffset); int sizeOfResultSoFar = result.size();
*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE; const int valueToAdd = sizeOfResultSoFar - EXIF_HEADER_SIZE;
*ptr = endianSwap(*ptr); // Latitude
} {
AddValueToU32AndEndianSwap(result.data() + latitudeOffset, valueToAdd);
}
// Longitude // Longitude
{ {
uint32_t *ptr = (uint32_t *) (result.data() + longitudeOffset); AddValueToU32AndEndianSwap(result.data() + longitudeOffset, valueToAdd);
*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
// Altitude // Altitude
{ {
uint32_t *ptr = (uint32_t *) (result.data() + altitudeOffset); AddValueToU32AndEndianSwap(result.data() + altitudeOffset, valueToAdd);
*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
}
// Track // Track
{ {
uint32_t *ptr = (uint32_t *) (result.data() + trackOffset); AddValueToU32AndEndianSwap(result.data() + trackOffset, valueToAdd);
*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE; }
*ptr = endianSwap(*ptr);
} }
// //
appendGPSCoords(result, latitude, true); AppendGPSCoords(result, latitude);
appendGPSCoords(result, longitude, true); AppendGPSCoords(result, longitude);
appendU32(result, altitude, true); AppendU32(result, altitude);
appendU32(result, 1, true); // denominator for altitude AppendU32(result, 1); // denominator for altitude
int const TRACK_PRECISION = 10000; int const TRACK_PRECISION = 10000;
appendU32(result, track * TRACK_PRECISION, true); AppendU32(result, track * TRACK_PRECISION);
appendU32(result, TRACK_PRECISION, true); AppendU32(result, TRACK_PRECISION);
return result; return result;
} }
std::string ExifBuilder::GetCurrentTimestamp()
{
auto now = std::chrono::system_clock::now();
std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
std::tm *timeInfo = std::localtime(&currentTime);
std::ostringstream oss;
oss << std::put_time(timeInfo, "%Y:%m:%d %H:%M:%S");
return oss.str();
}
} }

24
openVulkanoCpp/Image/ExifBuilder.hpp
View File

@@ -29,13 +29,16 @@ namespace OpenVulkano::Image
}; };
enum class GPSTrackRef enum class GPSTrackRef
{ {
TRUE_, TRUE_NORTH,
MAGNETIC MAGNETIC
}; };
struct GPSCoords struct GPSCoords
{ {
int32_t degrees, minutes, seconds; int32_t degrees, minutes, seconds;
GPSCoords(int32_t valueForAll = 0);
GPSCoords(int32_t degrees, int32_t minutes, int32_t seconds);
}; };
class ExifBuilder class ExifBuilder
@@ -44,26 +47,29 @@ namespace OpenVulkano::Image
int orientation = 0; int orientation = 0;
std::string make; std::string make;
std::string model; std::string model;
RationalValue xresolution = {0, 0}; RationalValue xResolution = { 0, 0 };
RationalValue yresolution = {0, 0}; RationalValue yResolution = { 0, 0 };
int resolutionUnit = 0; int resolutionUnit = 0;
RationalValue exposureTime = {0, 0}; RationalValue exposureTime = { 0, 0 };
std::string dateTaken; // format: yyyy:mm:dd hh:mm:ss std::string dateTaken; // format: yyyy:mm:dd hh:mm:ss
std::string softwareUsed; std::string softwareUsed = "OpenVulkano";
LatitudeRef latitudeRef = LatitudeRef::NORTH; LatitudeRef latitudeRef = LatitudeRef::NORTH;
GPSCoords latitude = {0, 0, 0}; GPSCoords latitude = { 0, 0, 0 };
LongitudeRef longitudeRef = LongitudeRef::EAST; LongitudeRef longitudeRef = LongitudeRef::EAST;
GPSCoords longitude = {0, 0, 0}; GPSCoords longitude = { 0, 0, 0 };
bool altitudeIsAboveSeaLevel = true; bool altitudeIsAboveSeaLevel = true;
uint32_t altitude = 0; uint32_t altitude = 0;
GPSTrackRef trackRef = GPSTrackRef::TRUE_; GPSTrackRef trackRef = GPSTrackRef::TRUE_NORTH;
float track = 0; // range is [0.0; 360.0) float track = 0; // range is [0.0; 360.0)
void SetAltitude(float level);
// Typical usage is -> jpeg_write_marker(cinfo, JPEG_APP0 + 1, exif_data.data(), exif_data.size()); // Typical usage is -> jpeg_write_marker(cinfo, JPEG_APP0 + 1, exif_data.data(), exif_data.size());
std::vector<uint8_t> build(); std::vector<uint8_t> Build();
static std::string GetCurrentTimestamp();
}; };
} }