ExifData *
exif_data_new (void)
{
ExifMem *mem = exif_mem_new_default ();
ExifData *d = exif_data_new_mem (mem);
exif_mem_unref (mem);
return d;
}
ExifData *
exif_loader_get_data (ExifLoader *loader)
{
ExifData *ed;
if (!loader)
return NULL;
ed = exif_data_new_mem (loader->mem);
exif_data_log (ed, loader->log);
exif_data_load_data (ed, loader->buf, loader->bytes_read);
return ed;
}
ExifData *
exif_loader_get_data (ExifLoader *loader)
{
ExifData *ed;
if (!loader || (loader->data_format == EL_DATA_FORMAT_UNKNOWN) ||
!loader->bytes_read)
return NULL;
ed = exif_data_new_mem (loader->mem);
exif_data_log (ed, loader->log);
exif_data_load_data (ed, loader->buf, loader->bytes_read);
return ed;
}
GstTagList *
gst_droidcamsrc_exif_tags_from_jpeg_data (void *data, size_t size)
{
GstTagList *tags = NULL;
ExifMem *mem = exif_mem_new (g_malloc0, g_realloc, g_free);
ExifData *exif = exif_data_new_mem (mem);
unsigned char *exif_data = NULL;
void *_exif_data = NULL;
unsigned int exif_data_size = 0;
GstBuffer *buffer;
ExifEntry *iso;
int x, i;
exif_data_load_data (exif, data, size);
exif_data_set_data_type (exif, EXIF_DATA_TYPE_COMPRESSED);
exif_data_save_data (exif, &exif_data, &exif_data_size);
if (!exif_data_size) {
goto out;
}
if (exif_data_size <= 6) {
goto out;
}
/* dump the data. based on libexif code */
for (x = 0; x < EXIF_IFD_COUNT; x++) {
if (exif->ifd[x] && exif->ifd[x]->count) {
for (i = 0; i < exif->ifd[x]->count; i++) {
char val[1024];
ExifEntry *e = exif->ifd[x]->entries[i];
GST_LOG ("Exif IFD: %s. Tag 0x%x (%s) = %s", exif_ifd_get_name (x),
e->tag, exif_tag_get_name_in_ifd (e->tag, exif_entry_get_ifd (e)),
exif_entry_get_value (e, val, sizeof (val)));
}
}
}
_exif_data = exif_data;
exif_data += 6;
exif_data_size -= 6;
buffer = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
exif_data, exif_data_size, 0, exif_data_size, NULL, NULL);
tags = gst_tag_list_from_exif_buffer_with_tiff_header (buffer);
gst_buffer_unref (buffer);
/* We don't want these tags */
gst_tag_list_remove_tag (tags, GST_TAG_DEVICE_MANUFACTURER);
gst_tag_list_remove_tag (tags, GST_TAG_DEVICE_MODEL);
gst_tag_list_remove_tag (tags, GST_TAG_APPLICATION_NAME);
gst_tag_list_remove_tag (tags, GST_TAG_DATE_TIME);
/* we have a mess with ISO so we will just behave as N9 */
iso = exif_content_get_entry (exif->ifd[EXIF_IFD_EXIF],
EXIF_TAG_ISO_SPEED_RATINGS);
if (iso) {
#ifdef __arm__
guint16 val = exif_get_short (iso->data, EXIF_BYTE_ORDER_MOTOROLA);
#else
guint16 val = exif_get_short (iso->data, EXIF_BYTE_ORDER_INTEL);
#endif
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE,
GST_TAG_CAPTURING_ISO_SPEED, val, NULL);
}
/* TODO: the following are being dropped
*
* 0x213 EXIF_TAG_YCBCR_POSITIONING
* 0x9004 EXIF_TAG_DATE_TIME_DIGITIZED
* 0x9101 EXIF_TAG_COMPONENTS_CONFIGURATION
* 0xa001 EXIF_TAG_COLOR_SPACE
* 0xa002 EXIF_TAG_PIXEL_X_DIMENSION
* 0xa003 EXIF_TAG_PIXEL_Y_DIMENSION
* 0xa005 EXIF_TAG_INTEROPERABILITY_IFD_POINTER
* thumbnail.
* 0x100 EXIF_TAG_IMAGE_WIDTH
* 0x101 EXIF_TAG_IMAGE_LENGTH
* 0x9203 EXIF_TAG_BRIGHTNESS_VALUE
* 0x9205 EXIF_TAG_MAX_APERTURE_VALUE
* 0x9206 EXIF_TAG_SUBJECT_DISTANCE
* 0x9208 EXIF_TAG_LIGHT_SOURCE
* 0x9286 EXIF_TAG_USER_COMMENT
*/
out:
if (_exif_data) {
exif_mem_free (mem, _exif_data);
}
if (exif) {
exif_data_free (exif);
}
exif_mem_unref (mem);
return tags;
}
void generateDecryptData(SGeoTagsEncrypt *collection, unsigned char *data, unsigned int size, ExifByteOrder order)
{
ExifEntry *entry = NULL;
ExifData *exif = NULL;
ExifContent *content = NULL;
// create new exif data
exif = exif_data_new_mem (exif_mem_new_default());
exif->priv->order = order;
// fill exif fields
exif_data_load_data_content(exif, EXIF_IFD_ENCRYPT, data, size, 0, 0);
content = exif->ifd[EXIF_IFD_ENCRYPT];
// excrypt version
exif_mem_read(collection->VersionID, NULL, content, SGEO_TAG_ENCRYPT_VERSION, sizeof(collection->VersionID));
// FileName
read_unicode_string_from_exif(content, SGEO_TAG_ENCRYPT_FILE_NAME, collection->FileName, sizeof(collection->FileName) / sizeof(*collection->FileName));
// FileSize
exif_long_read(&collection->FileSize, NULL, content, SGEO_TAG_ENCRYPT_FILE_SIZE, order);
// datetime
exif_mem_read(collection->DateTimeOriginal, &collection->ExistDateTimeOriginal, content, EXIF_TAG_DATE_TIME_ORIGINAL, sizeof(collection->DateTimeOriginal));
// Longitude
exif_srational_read(&collection->Longitude, &collection->ExistLongitude, content, SGEO_TAG_LONGITUDE, order);
// LongAccuracy
exif_rational_read(&collection->LongitudeAccuracy, &collection->ExistLongitudeAccuracy, content, SGEO_TAG_LONGACCURACY, order);
// Latitude
exif_srational_read(&collection->Latitude, &collection->ExistLatitude, content, SGEO_TAG_LATITUDE, order);
// LatAccuracy
exif_rational_read(&collection->LatitudeAccuracy, &collection->ExistLatitudeAccuracy, content, SGEO_TAG_LATACCURACY, order);
// Altitude
exif_srational_read(&collection->Altitude, &collection->ExistAltitude, content, SGEO_TAG_ALTITUDE, order);
// AltAccuracy
exif_rational_read(&collection->AltitudeAccuracy, &collection->ExistAltitudeAccuracy, content, SGEO_TAG_ALTACCURACY, order);
// Azimuth
exif_srational_read(&collection->Altitude, &collection->ExistAltitude, content, SGEO_TAG_ALTITUDE, order);
entry = exif_content_get_entry (content, (ExifTag)(SGEO_TAG_AZIMUTH));
if (entry) collection->Azimuth = exif_get_srational(entry->data, order);
// AzimuthAccuracy
exif_rational_read(&collection->AzimuthAccuracy, &collection->ExistAzimuthAccuracy, content, SGEO_TAG_AZIMUTHACCURACY, order);
// Pitch
exif_srational_read(&collection->Pitch, &collection->ExistPitch, content, SGEO_TAG_PITCH, order);
// PitchAccuracy
exif_rational_read(&collection->PitchAccuracy, &collection->ExistPitchAccuracy, content, SGEO_TAG_PITCHACCURACY, order);
// Roll
exif_srational_read(&collection->Roll, &collection->ExistRoll, content, SGEO_TAG_ROLL, order);
// RollAccuracy
exif_rational_read(&collection->RollAccuracy, &collection->ExistRollAccuracy, content, SGEO_TAG_ROLLACCURACY, order);
// HViewAngle
exif_rational_read(&collection->HViewAngle, &collection->ExistHViewAngle, content, SGEO_TAG_HVIEWANGLE, order);
// HViewAngleAccuracy
exif_rational_read(&collection->HViewAngleAccuracy, &collection->ExistHViewAngleAccuracy, content, SGEO_TAG_HVIEWANGLEACCURACY, order);
// VViewAngle
exif_rational_read(&collection->VViewAngle, &collection->ExistVViewAngle, content, SGEO_TAG_VVIEWANGLE, order);
// VViewAngleAccuracy
exif_rational_read(&collection->VViewAngleAccuracy, &collection->ExistVViewAngleAccuracy, content, SGEO_TAG_VVIEWANGLEACCURACY, order);
// SatCount
exif_mem_read(&collection->SatCount, NULL, content, SGEO_TAG_SATCOUNT, sizeof(collection->SatCount));
// global time
exif_mem_read(&collection->GlobalTime, &collection->ExistGlobalTime, content, SGEO_TAG_GLOBAL_TIME, sizeof(collection->GlobalTime));
// GNSSType
exif_long_read(&collection->GNSSType, NULL, content, SGEO_TAG_GNSS_TYPE, order);
// DeviceName
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_NAME, collection->DeviceName, sizeof(collection->DeviceName) / sizeof(*collection->DeviceName));
// DeviceIMEI
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_IMEI, collection->DeviceIMEI, sizeof(collection->DeviceIMEI) / sizeof(*collection->DeviceIMEI));
// DeviceNumber
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_NUMBER, collection->DeviceNumber, sizeof(collection->DeviceNumber) / sizeof(*collection->DeviceNumber));
// DeviceOS
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_OS, collection->DeviceOS, sizeof(collection->DeviceOS) / sizeof(*collection->DeviceOS));
// DeviceOSVersion
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_OS_VERSION, collection->DeviceOSVersion, sizeof(collection->DeviceOSVersion) / sizeof(*collection->DeviceOSVersion));
// DeviceVersion
read_unicode_string_from_exif(content, SGEO_TAG_DEVICE_VERSION, collection->DeviceVersion, sizeof(collection->DeviceVersion) / sizeof(*collection->DeviceVersion));
// DeviceDateTimeMeasure
exif_mem_read(&collection->DeviceDateTimeMeasure, NULL, content, SGEO_TAG_DEVICE_DATE_TIME_MEASURE, sizeof(collection->DeviceDateTimeMeasure));
// ProgramVersion
read_unicode_string_from_exif(content, SGEO_TAG_PROGRAM_VERSION, collection->ProgramVersion, sizeof(collection->ProgramVersion) / sizeof(*collection->ProgramVersion));
// ProgramName
read_unicode_string_from_exif(content, SGEO_TAG_PROGRAM_NAME, collection->ProgramName, sizeof(collection->ProgramName) / sizeof(*collection->ProgramName));
// ProgramUserName
read_unicode_string_from_exif(content, SGEO_TAG_PROGRAM_USER_NAME, collection->ProgramUserName, sizeof(collection->ProgramUserName) / sizeof(*collection->ProgramUserName));
exif_data_unref(exif);
}
void add_sgeo_app2(JPEGData *jdata, SGeoTags *sgeo_tags, ExifData *exif)
{
int number = 2;
int i;
JPEGSection *section = NULL;
JPEGSection temp;
int section_for_sgeo_need = 1;// + (int)sgeo_tags->StaticMapCount;
int index_insert = 0;
int is_insert_map = 0;
ExifData *exif_sgeo = NULL;
ExifEntry *entry_version_id = NULL;// store SGEO_TAG_VERSIONID for SGEO Map
ExifByteOrder order;
order = exif_data_get_byte_order(exif);
if (jdata == NULL)
return;
// find and exclude all SGEO in APP2
for (i = 0; i < (int)jdata->count; i++)
{
section = &jdata->sections[i];
if (section->marker == JPEG_MARKER_APP2)
{
// detecting SGEO by data
if (is_sgeo_app2(section->content._generic.data))
{
jpeg_data_exclude_section(jdata, section);
i = -1;
}
}
}
section = NULL;
for (i = 0; i < (int)jdata->count; i++)
{
section = &jdata->sections[i];
if (section->marker == JPEG_MARKER_APP1)
{
index_insert = i + 1;
break;
}
}
while (section_for_sgeo_need--)
{
// add section
jpeg_data_append_section(jdata);
// move section to index_insert
i = jdata->count - 1;
temp = jdata->sections[i];
for (; i > index_insert; i--)
jdata->sections[i] = jdata->sections[i - 1];
jdata->sections[i] = temp;
exif_sgeo = exif_data_new_mem (exif->priv->mem);
exif_sgeo->priv->order = exif->priv->order;
// write exif_sgeo
if (is_insert_map)
{
// add enrty with SGEO version
//if (entry_version_id != NULL)
// exif_content_add_entry (exif_sgeo->ifd[EXIF_IFD_SGEO], entry_version_id);
//write_sgeo_tags_map(exif_sgeo, EXIF_IFD_SGEO, &sgeo_tags->StaticMapData[is_insert_map - 1]);
}
else
{
write_sgeo_tags(exif_sgeo, EXIF_IFD_SGEO, sgeo_tags);
entry_version_id = exif_content_get_entry(exif_sgeo->ifd[EXIF_IFD_SGEO], (ExifTag)SGEO_TAG_VERSIONID);
entry_version_id->priv->ref_count++;
}
// write data
write_sgeo_app2(&jdata->sections[i], exif_sgeo);
exif_data_unref(exif_sgeo);
exif_sgeo = NULL;
entry_version_id->parent = NULL;
// increase index
index_insert++;
is_insert_map++;
}
exif_entry_unref (entry_version_id);
}
void generateEncryptData(unsigned char **data, unsigned int *size, SGeoTagsEncrypt *collection, ExifByteOrder order)
{
unsigned int i = 0;
unsigned int s = 0;
unsigned int next_data = 0;
ExifEntry *entry = NULL;
ExifContent *content = NULL;
unsigned char *d = NULL, n;
ExifData *exif = NULL;
int size_sgeo_bytes = 0;
ExifIfd ifd = EXIF_IFD_ENCRYPT;
srand((unsigned int)time(NULL));
*data = NULL;
*size = 0;
exif = exif_data_new_mem (exif_mem_new_default());
exif->priv->order = order;
content = exif->ifd[EXIF_IFD_ENCRYPT];
// VersionID
exif_mem_write(content, SGEO_TAG_ENCRYPT_VERSION, EXIF_FORMAT_BYTE, collection->VersionID, sizeof(collection->VersionID), NULL);
// FileName
write_unicode_string_to_exif(content, SGEO_TAG_ENCRYPT_FILE_NAME, collection->FileName);
// FileSize
exif_long_write(content, SGEO_TAG_ENCRYPT_FILE_SIZE, &collection->FileSize, order, NULL);
// DateTimeOriginal
exif_mem_write(content, EXIF_TAG_DATE_TIME_ORIGINAL, EXIF_FORMAT_ASCII, collection->DateTimeOriginal, sizeof(collection->DateTimeOriginal), &collection->ExistDateTimeOriginal);
// Longitude
exif_srational_write(content, SGEO_TAG_LONGITUDE, &collection->Longitude, order, &collection->ExistLongitude);
// LongAccuracy
exif_rational_write(content, SGEO_TAG_LONGACCURACY, &collection->LongitudeAccuracy, order, &collection->ExistLongitudeAccuracy);
// Latitude
exif_srational_write(content, SGEO_TAG_LATITUDE, &collection->Latitude, order, &collection->ExistLatitude);
// LatAccuracy
exif_rational_write(content, SGEO_TAG_LATACCURACY, &collection->LatitudeAccuracy, order, &collection->ExistLatitudeAccuracy);
// Altitude
exif_srational_write(content, SGEO_TAG_ALTITUDE, &collection->Altitude, order, &collection->ExistAltitude);
// AltAccuracy
exif_rational_write(content, SGEO_TAG_ALTACCURACY, &collection->AltitudeAccuracy, order, &collection->ExistAltitudeAccuracy);
// Azimuth
exif_srational_write(content, SGEO_TAG_AZIMUTH, &collection->Azimuth, order, &collection->ExistAzimuth);
// AzimuthAccuracy
exif_rational_write(content, SGEO_TAG_AZIMUTHACCURACY, &collection->AzimuthAccuracy, order, &collection->ExistAzimuthAccuracy);
// Pitch
exif_srational_write(content, SGEO_TAG_PITCH, &collection->Pitch, order, &collection->ExistPitch);
// PitchAccuracy
exif_rational_write(content, SGEO_TAG_PITCHACCURACY, &collection->PitchAccuracy, order, &collection->ExistPitchAccuracy);
// Roll
exif_srational_write(content, SGEO_TAG_ROLL, &collection->Roll, order, &collection->ExistRoll);
// RollAccuracy
exif_rational_write(content, SGEO_TAG_ROLLACCURACY, &collection->RollAccuracy, order, &collection->ExistRollAccuracy);
// HViewAngle
exif_rational_write(content, SGEO_TAG_HVIEWANGLE, &collection->HViewAngle, order, &collection->ExistHViewAngle);
// HViewAngleAccuracy
exif_rational_write(content, SGEO_TAG_HVIEWANGLEACCURACY, &collection->HViewAngleAccuracy, order, &collection->ExistHViewAngleAccuracy);
// VViewAngle
exif_rational_write(content, SGEO_TAG_VVIEWANGLE, &collection->VViewAngle, order, &collection->ExistVViewAngle);
// VViewAngleAccuracy
exif_rational_write(content, SGEO_TAG_VVIEWANGLEACCURACY, &collection->VViewAngleAccuracy, order, &collection->ExistVViewAngleAccuracy);
// SatCount
exif_mem_write(content, SGEO_TAG_SATCOUNT, EXIF_FORMAT_BYTE, &collection->SatCount, sizeof(collection->SatCount), NULL);
// global time
exif_mem_write(content, SGEO_TAG_GLOBAL_TIME, EXIF_FORMAT_BYTE, collection->GlobalTime, sizeof(collection->GlobalTime), NULL);
// GNSSType
exif_long_write(content, SGEO_TAG_GNSS_TYPE, &collection->GNSSType, order, NULL);
// DeviceName
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_NAME, collection->DeviceName);
// DeviceIMEI
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_IMEI, collection->DeviceIMEI);
// DeviceNumber
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_NUMBER, collection->DeviceNumber);
// DeviceOS
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_OS, collection->DeviceOS);
// DeviceOSVersion
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_OS_VERSION, collection->DeviceOSVersion);
// DeviceVersion
write_unicode_string_to_exif(content, SGEO_TAG_DEVICE_VERSION, collection->DeviceVersion);
// DeviceDateTimeMeasure
exif_mem_write(content, SGEO_TAG_DEVICE_DATE_TIME_MEASURE, EXIF_FORMAT_BYTE, collection->DeviceDateTimeMeasure, sizeof(collection->DeviceDateTimeMeasure), NULL);
// ProgramVersion
write_unicode_string_to_exif(content, SGEO_TAG_PROGRAM_VERSION, collection->ProgramVersion);
// ProgramName
write_unicode_string_to_exif(content, SGEO_TAG_PROGRAM_NAME, collection->ProgramName);
// ProgramUserName
write_unicode_string_to_exif(content, SGEO_TAG_PROGRAM_USER_NAME, collection->ProgramUserName);
size_sgeo_bytes = 2 + content->count * 12;
for (i = 0; i < content->count; i++)
{
entry = content->entries[i];
if (entry != NULL)
{
s = exif_format_get_size(entry->format) * entry->components;
if (s > 4)
size_sgeo_bytes += s;
// s += 12;// +tag size
//else
// s = 12;
}
}
if (size_sgeo_bytes > 0)
{
*data = (unsigned char* )calloc((size_t)size_sgeo_bytes, 1);
if (*data != NULL)
{
write_content_binary(*data, content, order, 0);
s = 0;
if (size_sgeo_bytes < 1024)
s = 1024 - size_sgeo_bytes;
s += 2390;// white noice
*size = size_sgeo_bytes + s;
*data = (unsigned char* )realloc(*data, (size_t)(size_sgeo_bytes + s));
n = rand() % 255;
for (i = 0; i < s; i++)
{
n = GaloisLfsr(n);
(*data)[size_sgeo_bytes + i] = n;
}
}
}
exif_data_unref(exif);
}
