Sirius2C::Sirius2C( ChannelWPtr parent // родительский канал
, const string_t& deviceId // идентификатор устройства в системе
, const int32_t deviceType // тип устройства
, const int32_t serialId // серийный номер устройства / пароль
, const int32_t modbusId // номер устройства в сети modbus
, const int32_t primeCurrent // первичный ток
, const int32_t secondCurrent // вторичный ток
)
: Sirius2Base(parent, deviceId, deviceType, "Сириус-2-С", serialId, modbusId)
{
paramTags.DI16 = Sirius2Base::WithPrefix("DI16");
paramTags.I = Sirius2Base::WithPrefix("I");
paramTags.Ia = Sirius2Base::WithPrefix("Ia");
paramTags.Ib = Sirius2Base::WithPrefix("Ib");
paramTags.Ic = Sirius2Base::WithPrefix("Ic");
Sirius2Base::AddTag(paramTags.DI16, ComVariant(uint16_t(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.I, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ia, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ib, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ic, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(Sirius2Base::WithPrefix("I_unit"), ComVariant(string_t("А")), OPC_QUALITY_GOOD);
// data request
// discrete
{
RequestRTU request;
request.startAdress = modbusId;
request.func = 2;
request.startAdress = 72;
request.byteCount = 2;
request.tags.push_back( TagInfo(paramTags.DI16, 18) );
Sirius2Base::AddRequest(request);
}
// analog
{
RequestRTU request;
request.startAdress = modbusId;
request.func = 3;
request.startAdress = 1280;
request.byteCount = 6;
float factor = static_cast<float>(primeCurrent / secondCurrent);
request.tags.push_back( TagInfo(paramTags.Ia, 4, factor /* А */) );
request.tags.push_back( TagInfo(paramTags.Ib, 4, factor /* А */) );
request.tags.push_back( TagInfo(paramTags.Ic, 4, factor /* А */) );
Sirius2Base::AddRequest(request);
}
}
namespace Exiv2 {
// Sony MakerNote Tag Info
const TagInfo SonyMakerNote::tagInfo_[] = {
TagInfo(0x2000, "0x2000", "0x2000",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9001, "0x9001", "0x9001",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9002, "0x9002", "0x9002",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9003, "0x9003", "0x9003",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9004, "0x9004", "0x9004",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9005, "0x9005", "0x9005",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9006, "0x9006", "0x9006",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9007, "0x9007", "0x9007",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9008, "0x9008", "0x9008",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownSonyMakerNoteTag)", "(UnknownSonyMakerNoteTag)",
N_("Unknown SonyMakerNote tag"),
sonyIfdId, makerTags, invalidTypeId, printValue)
};
const TagInfo* SonyMakerNote::tagList()
{
return tagInfo_;
}
} // namespace Exiv2
static int GetTrackAVInf( TS_CHANNEL_PARSER *pTSChannelParser, int nIndex, char* pBuffer, int nSize )
{
int pos = 0;
char *p = pBuffer;
TS_ELEMENT *ts_elmnt = &pTSChannelParser->ts_streams.ts_element[nIndex];
AV_ELEMENT *av_elmnt = &pTSChannelParser->av_streams.av_element[nIndex];
ES_BUFFER_ *es_buffer = &pTSChannelParser->es_buffer[nIndex];
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "[" );
pos += AVElmntInfo( av_elmnt, p+pos, nSize-pos );
if ( es_buffer->main_track )
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "main=yes;" );
pos += TagInfo( 1, ts_elmnt, NULL, p+pos, nSize-pos );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "index=%d;", nIndex );
if ( nSize > pos+2 ) { p[pos++] = ']'; p[pos++] = ';'; } //terminator
return pos;
}
inline std::size_t listTags(Config const &config) {
TestSpec testSpec = config.testSpec();
if (config.testSpec().hasFilters())
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
}
std::map<std::string, TagInfo> tagCounts;
std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
it != itEnd;
++it) {
for (std::set<std::string>::const_iterator tagIt = it->getTestCaseInfo().tags.begin(),
tagItEnd = it->getTestCaseInfo().tags.end();
tagIt != tagItEnd;
++tagIt) {
std::string tagName = *tagIt;
std::string lcaseTagName = toLower(tagName);
std::map<std::string, TagInfo>::iterator countIt = tagCounts.find(lcaseTagName);
if (countIt == tagCounts.end())
countIt = tagCounts.insert(std::make_pair(lcaseTagName, TagInfo())).first;
countIt->second.add(tagName);
}
}
for (std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
countItEnd = tagCounts.end();
countIt != countItEnd;
++countIt) {
std::ostringstream oss;
oss << " " << std::setw(2) << countIt->second.count << " ";
Text wrapper(countIt->second.all(), TextAttributes()
.setInitialIndent(0)
.setIndent(oss.str().size())
.setWidth(CATCH_CONFIG_CONSOLE_WIDTH - 10));
Catch::cout() << oss.str() << wrapper << "\n";
}
Catch::cout() << pluralise(tagCounts.size(), "tag") << "\n" << std::endl;
return tagCounts.size();
}
Sirius2D::Sirius2D( ChannelWPtr parent
, const string_t& deviceId
, const int32_t deviceType
, const int32_t serialId
, const int32_t modbusId
, const int32_t primeCurrent
, const int32_t secondCurrent
, const int32_t primeVoltage
, const int32_t secondVoltage )
: Sirius2Base(parent, deviceId, deviceType, "Сириус-2-Д", serialId, modbusId)
{
paramTags.DI16 = Sirius2Base::WithPrefix("DI16");
paramTags.U = Sirius2Base::WithPrefix("U");
paramTags.Ua = Sirius2Base::WithPrefix("Ua");
paramTags.Uax = Sirius2Base::WithPrefix("Uax");
paramTags.Uay = Sirius2Base::WithPrefix("Uay");
paramTags.Ub = Sirius2Base::WithPrefix("Ub");
paramTags.Ubx = Sirius2Base::WithPrefix("Ubx");
paramTags.Uby = Sirius2Base::WithPrefix("Uby");
paramTags.Uc = Sirius2Base::WithPrefix("Uc");
paramTags.Ucx = Sirius2Base::WithPrefix("Ucx");
paramTags.Ucy = Sirius2Base::WithPrefix("Ucy");
paramTags.I = Sirius2Base::WithPrefix("I");
paramTags.Ia = Sirius2Base::WithPrefix("Ia");
paramTags.Iax = Sirius2Base::WithPrefix("Iax");
paramTags.Iay = Sirius2Base::WithPrefix("Iay");
paramTags.Ib = Sirius2Base::WithPrefix("Ib");
paramTags.Ibx = Sirius2Base::WithPrefix("Ibx");
paramTags.Iby = Sirius2Base::WithPrefix("Iby");
paramTags.Ic = Sirius2Base::WithPrefix("Ic");
paramTags.Icx = Sirius2Base::WithPrefix("Icx");
paramTags.Icy = Sirius2Base::WithPrefix("Icy");
paramTags.I0x = Sirius2Base::WithPrefix("I0x");
paramTags.I0y = Sirius2Base::WithPrefix("I0y");
paramTags.I2x = Sirius2Base::WithPrefix("I2x");
paramTags.I2y = Sirius2Base::WithPrefix("I2y");
paramTags.P = Sirius2Base::WithPrefix("P");
paramTags.Q = Sirius2Base::WithPrefix("Q");
Sirius2Base::AddTag(paramTags.DI16, ComVariant(uint16_t(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.U, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ua, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Uax, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Uay, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ub, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ubx, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Uby, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Uc, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ucx, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ucy, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(Sirius2Base::WithPrefix("U_unit"), ComVariant(string_t("кВ")), OPC_QUALITY_GOOD);
Sirius2Base::AddTag(paramTags.I, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ia, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Iax, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Iay, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ib, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ibx, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Iby, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Ic, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Icx, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.Icy, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.I0x, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.I0y, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.I2x, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(paramTags.I2y, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(Sirius2Base::WithPrefix("I_unit"), ComVariant(string_t("А")), OPC_QUALITY_GOOD);
Sirius2Base::AddTag(paramTags.P, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(Sirius2Base::WithPrefix("P_unit"), ComVariant(string_t("МВт")), OPC_QUALITY_GOOD);
Sirius2Base::AddTag(paramTags.Q, ComVariant(float(0)), OPC_QUALITY_BAD);
Sirius2Base::AddTag(Sirius2Base::WithPrefix("Q_unit"), ComVariant(string_t("МВр")), OPC_QUALITY_GOOD);
// data request
// discrete
{
RequestRTU request;
request.startAdress = modbusId;
request.func = 2;
request.startAdress = 72;
request.byteCount = 2;
request.tags.push_back( TagInfo(paramTags.DI16, 18) );
Sirius2Base::AddRequest(request);
}
// analog
{
RequestRTU request;
request.startAdress = modbusId;
request.func = 3;
request.startAdress = 1298;
request.byteCount = 32;
float factorCurrent = static_cast<float>(primeCurrent / secondCurrent);
request.tags.push_back( TagInfo(paramTags.Iax, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.Iay, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.Ibx, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.Iby, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.Icx, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.Icy, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.I2x, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.I2y, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.I0x, 4, factorCurrent /* А */) );
request.tags.push_back( TagInfo(paramTags.I0y, 4, factorCurrent /* А */) );
float factorVoltage = static_cast<float>(primeVoltage / secondVoltage / 1000);
request.tags.push_back( TagInfo(paramTags.Uax, 4, factorVoltage /* кВ */) );
request.tags.push_back( TagInfo(paramTags.Uay, 4, factorVoltage /* кВ */) );
request.tags.push_back( TagInfo(paramTags.Ubx, 4, factorVoltage /* кВ */) );
request.tags.push_back( TagInfo(paramTags.Uby, 4, factorVoltage /* кВ */) );
request.tags.push_back( TagInfo(paramTags.Ucx, 4, factorVoltage /* кВ */) );
request.tags.push_back( TagInfo(paramTags.Ucy, 4, factorVoltage /* кВ */) );
Sirius2Base::AddRequest(request);
}
}
namespace Exiv2 {
//! @cond IGNORE
OlympusMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote(
"OLYMPUS*", "*", createOlympusMakerNote);
MakerNoteFactory::registerMakerNote(
olympusIfdId, MakerNote::AutoPtr(new OlympusMakerNote));
ExifTags::registerMakerTagInfo(olympusIfdId, tagInfo_);
}
//! @endcond
// Olympus Tag Info
const TagInfo OlympusMakerNote::tagInfo_[] = {
TagInfo(0x0200, "SpecialMode", "SpecialMode", "Picture taking mode", olympusIfdId, makerTags, unsignedLong, print0x0200),
TagInfo(0x0201, "Quality", "Quality", "Image quality setting", olympusIfdId, makerTags, unsignedShort, print0x0201),
TagInfo(0x0202, "Macro", "Macro", "Macro mode", olympusIfdId, makerTags, unsignedShort, print0x0202),
TagInfo(0x0203, "BWMode", "BWMode", "Black and White Mode", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0204, "DigitalZoom", "DigitalZoom", "Digital zoom ratio", olympusIfdId, makerTags, unsignedRational, print0x0204),
TagInfo(0x0205, "FocalPlaneDiagonal", "FocalPlaneDiagonal", "Focal plane diagonal", olympusIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x0206, "0x0206", "0x0206", "Unknown", olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x0207, "FirmwareVersion", "FirmwareVersion", "Software firmware version", olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0208, "PictureInfo", "PictureInfo", "ASCII format data such as [PictureInfo]", olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0209, "CameraID", "CameraID", "CameraID data", olympusIfdId, makerTags, undefined, printValue),
TagInfo(0x0300, "PreCaptureFrames", "PreCaptureFrames", "Pre-capture frames", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0301, "0x0301", "0x0301", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0302, "OneTouchWB", "OneTouchWB", "OneTouchWB", olympusIfdId, makerTags, unsignedShort, print0x0302),
TagInfo(0x0303, "0x0303", "0x0303", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0304, "0x0304", "0x0304", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0f00, "DataDump", "DataDump", "Various camera settings", olympusIfdId, makerTags, undefined, printValue),
TagInfo(0x1000, "0x1000", "0x1000", "Unknown", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1001, "0x1001", "0x1001", "Unknown", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1002, "0x1002", "0x1002", "Unknown", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1003, "0x1003", "0x1003", "Unknown", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1004, "FlashMode", "FlashMode", "Flash mode", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1005, "FlashDevice", "FlashDevice", "Flash device", olympusIfdId, makerTags, unsignedShort, print0x1005),
TagInfo(0x1006, "Bracket", "Bracket", "Bracket", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1007, "0x1007", "0x1007", "Unknown", olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x1008, "0x1008", "0x1008", "Unknown", olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x1009, "0x1009", "0x1009", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100a, "0x100a", "0x100a", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100b, "FocusMode", "FocusMode", "Focus mode", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100c, "FocusDistance", "FocusDistance", "Focus distance", olympusIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x100d, "Zoom", "Zoom", "Zoom", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100e, "MacroFocus", "MacroFocus", "Macro focus", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100f, "SharpnessFactor", "SharpnessFactor", "Sharpness factor", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1010, "0x1010", "0x1010", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1011, "ColorMatrix", "ColorMatrix", "Color matrix", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1012, "BlackLevel", "BlackLevel", "Black level", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1013, "0x1013", "0x1013", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1014, "0x1014", "0x1014", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1015, "WhiteBalance", "WhiteBalance", "White balance", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1016, "0x1016", "0x1016", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1017, "RedBalance", "RedBalance", "Red balance", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1018, "BlueBalance", "BlueBalance", "Blue balance", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1019, "0x1019", "0x1019", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x101a, "SerialNumber", "SerialNumber", "Serial number", olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x101b, "0x101b", "0x101b", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101c, "0x101c", "0x101c", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101d, "0x101d", "0x101d", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101e, "0x101e", "0x101e", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101f, "0x101f", "0x101f", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1020, "0x1020", "0x1020", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1021, "0x1021", "0x1021", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1022, "0x1022", "0x1022", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1023, "FlashBias", "FlashBias", "Flash bias", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1024, "0x1024", "0x1024", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1025, "0x1025", "0x1025", "Unknown", olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1026, "0x1026", "0x1026", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1027, "0x1027", "0x1027", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1028, "0x1028", "0x1028", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1029, "Contrast", "Contrast", "Contrast setting", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102a, "SharpnessFactor", "SharpnessFactor", "Sharpness factor", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102b, "ColorControl", "ColorControl", "Color control", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102c, "ValidBits", "ValidBits", "Valid bits", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102d, "CoringFilter", "CoringFilter", "Coring filter", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102e, "ImageWidth", "ImageWidth", "Image width", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x102f, "ImageHeight", "ImageHeight", "Image height", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1030, "0x1030", "0x1030", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1031, "0x1031", "0x1031", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1032, "0x1032", "0x1032", "Unknown", olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1033, "0x1033", "0x1033", "Unknown", olympusIfdId, makerTags, unsignedLong, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownOlympusMakerNoteTag)", "(UnknownOlympusMakerNoteTag)", "Unknown OlympusMakerNote tag", olympusIfdId, makerTags, invalidTypeId, printValue)
};
OlympusMakerNote::OlympusMakerNote(bool alloc)
: IfdMakerNote(olympusIfdId, alloc)
{
byte buf[] = {
'O', 'L', 'Y', 'M', 'P', 0x00, 0x01, 0x00
};
readHeader(buf, 8, byteOrder_);
}
OlympusMakerNote::OlympusMakerNote(const OlympusMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int OlympusMakerNote::readHeader(const byte* buf,
long len,
ByteOrder byteOrder)
{
if (len < 8) return 1;
// Copy the header
header_.alloc(8);
memcpy(header_.pData_, buf, header_.size_);
// Adjust the offset of the IFD for the prefix
start_ = 8;
return 0;
}
int OlympusMakerNote::checkHeader() const
{
int rc = 0;
// Check the OLYMPUS prefix
if ( header_.size_ < 8
|| std::string(reinterpret_cast<char*>(header_.pData_), 5)
!= std::string("OLYMP", 5)) {
rc = 2;
}
return rc;
}
OlympusMakerNote::AutoPtr OlympusMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
OlympusMakerNote* OlympusMakerNote::create_(bool alloc) const
{
AutoPtr makerNote = AutoPtr(new OlympusMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
OlympusMakerNote::AutoPtr OlympusMakerNote::clone() const
{
return AutoPtr(clone_());
}
OlympusMakerNote* OlympusMakerNote::clone_() const
{
return new OlympusMakerNote(*this);
}
std::ostream& OlympusMakerNote::print0x0200(std::ostream& os,
const Value& value)
{
if (value.count() != 3 || value.typeId() != unsignedLong) {
return os << value;
}
long l0 = value.toLong(0);
switch (l0) {
case 0: os << "Normal"; break;
case 2: os << "Fast"; break;
case 3: os << "Panorama"; break;
default: os << "(" << l0 << ")"; break;
}
if (l0 != 0) {
os << ", ";
long l1 = value.toLong(1);
os << "Sequence number " << l1;
}
if (l0 != 0 && l0 != 2) {
os << ", ";
long l2 = value.toLong(2);
switch (l2) {
case 1: os << "Left to Right"; break;
case 2: os << "Right to Left"; break;
case 3: os << "Bottom to Top"; break;
case 4: os << "Top to Bottom"; break;
default: os << "(" << l2 << ")"; break;
}
}
return os;
} // OlympusMakerNote::print0x0200
//! Quality
const TagDetails quality[] = {
{ 0, "(start)" },
{ 1, "Standard Quality (SQ)" },
{ 2, "High Quality (HQ)" },
{ 3, "Super High Quality (SHQ)" },
{ 6, "Raw" },
{ 0, "(end)" }
};
std::ostream& OlympusMakerNote::print0x0201(std::ostream& os,
const Value& value)
{
return TagTranslator(quality).print(os, value);
} // OlympusMakerNote::print0x0201
//! Macro
const TagDetails macro[] = {
{ -1, "(start)" },
{ 0, "Off" },
{ 1, "On" },
{ 2, "Super Macro" },
{ -1, "(end)" }
};
std::ostream& OlympusMakerNote::print0x0202(std::ostream& os,
const Value& value)
{
return TagTranslator(macro).print(os, value);
} // OlympusMakerNote::print0x0202
std::ostream& OlympusMakerNote::print0x0204(std::ostream& os,
const Value& value)
{
float f = value.toFloat();
if (f == 0.0 || f == 1.0) return os << "None";
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1) << f << "x";
os.copyfmt(oss);
return os;
} // OlympusMakerNote::print0x0204
//! OneTouchWB
const TagDetails oneTouchWb[] = {
{ -1, "(start)" },
{ 0, "Off" },
{ 1, "On" },
{ 2, "On (Preset)" },
{ -1, "(end)" }
};
std::ostream& OlympusMakerNote::print0x0302(std::ostream& os,
const Value& value)
{
return TagTranslator(oneTouchWb).print(os, value);
} // OlympusMakerNote::print0x0302
//! FlashDevice
const TagDetails flashDevice[] = {
{ -1, "(start)" },
{ 0, "None" },
{ 1, "Internal" },
{ 4, "External" },
{ 4, "Internal + External" },
{ -1, "(end)" }
};
std::ostream& OlympusMakerNote::print0x1005(std::ostream& os,
const Value& value)
{
return TagTranslator(flashDevice).print(os, value);
} // OlympusMakerNote::print0x1005
// *****************************************************************************
// free functions
MakerNote::AutoPtr createOlympusMakerNote(bool alloc,
const byte* buf,
long len,
ByteOrder byteOrder,
long offset)
{
return MakerNote::AutoPtr(new OlympusMakerNote(alloc));
}
} // namespace Exiv2
namespace Internal {
// -- Standard Sony Makernotes tags ---------------------------------------------------------------
//! Lookup table to translate Sony Auto HDR values to readable labels
extern const TagDetails sonyHDRMode[] = {
{ 0x00000, N_("Off") },
{ 0x10001, N_("Auto") },
{ 0x10010, "1" },
{ 0x10012, "2" },
{ 0x10014, "3" },
{ 0x10016, "4" },
{ 0x10018, "5" }
};
//! Lookup table to translate Sony model ID values to readable labels
extern const TagDetails sonyModelId[] = {
{ 2, "DSC-R1" },
{ 256, "DSLR-A100" },
{ 257, "DSLR-A900" },
{ 258, "DSLR-A700" },
{ 259, "DSLR-A200" },
{ 260, "DSLR-A350" },
{ 261, "DSLR-A300" },
{ 263, "DSLR-A380" },
{ 264, "DSLR-A330" },
{ 265, "DSLR-A230" },
{ 269, "DSLR-A850" },
{ 273, "DSLR-A550" },
{ 274, "DSLR-A500" },
{ 275, "DSLR-A450" },
{ 278, "NEX-5" },
{ 279, "NEX-3" }
};
//! Lookup table to translate Sony dynamic range optimizer values to readable labels
extern const TagDetails print0xb025[] = {
{ 0, N_("Off") },
{ 1, N_("Standard ") },
{ 2, N_("Advanced Auto") },
{ 3, N_("Auto") },
{ 8, N_("Advanced Lv1") },
{ 9, N_("Advanced Lv2") },
{ 10, N_("Advanced Lv3") },
{ 11, N_("Advanced Lv4") },
{ 12, N_("Advanced Lv5") },
{ 16, "1" },
{ 17, "2" },
{ 18, "3" },
{ 19, "4" },
{ 20, "5" }
};
//! Lookup table to translate Sony exposure mode values to readable labels
extern const TagDetails sonyExposureMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Portrait") },
{ 2, N_("Beach") },
{ 4, N_("Snow") },
{ 5, N_("Landscape ") },
{ 6, N_("Program") },
{ 7, N_("Aperture priority") },
{ 8, N_("Shutter priority") },
{ 9, N_("Night Scene / Twilight") },
{ 10, N_("Hi-Speed Shutter") },
{ 11, N_("Twilight Portrait") },
{ 12, N_("Soft Snap") },
{ 13, N_("Fireworks") },
{ 14, N_("Smile Shutter") },
{ 15, N_("Manual") },
{ 18, N_("High Sensitivity") },
{ 20, N_("Advanced Sports Shooting") },
{ 29, N_("Underwater") },
{ 33, N_("Gourmet") },
{ 34, N_("Panorama") },
{ 35, N_("Handheld Twilight") },
{ 36, N_("Anti Motion Blur") },
{ 37, N_("Pet") },
{ 38, N_("Backlight Correction HDR") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony JPEG Quality values to readable labels
extern const TagDetails sonyJPEGQuality[] = {
{ 0, N_("Normal") },
{ 1, N_("Fine") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony anti-blur values to readable labels
extern const TagDetails sonyAntiBlur[] = {
{ 0, N_("Off") },
{ 1, N_("On (Continuous)") },
{ 2, N_("On (Shooting)") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony dynamic range optimizer values to readable labels
extern const TagDetails print0xb04f[] = {
{ 0, N_("Off") },
{ 1, N_("Standard") },
{ 2, N_("Plus") }
};
//! Lookup table to translate Sony Intelligent Auto values to readable labels
extern const TagDetails sonyIntelligentAuto[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("Advanced") }
};
//! Lookup table to translate Sony WB values to readable labels
extern const TagDetails sonyWhiteBalance[] = {
{ 0, N_("Auto") },
{ 4, N_("Manual") },
{ 5, N_("Daylight") },
{ 6, N_("Cloudy") },
{ 7, N_("White Flourescent") },
{ 8, N_("Cool White Flourescent") },
{ 9, N_("Day White Flourescent") },
{ 14, N_("Incandescent") },
{ 15, N_("Flash") },
{ 17, N_("Underwater 1 (Blue Water)") },
{ 18, N_("Underwater 2 (Green Water)") }
};
//! Lookup table to translate Sony AF mode values to readable labels
extern const TagDetails sonyFocusMode[] = {
{ 1, "AF-S" },
{ 2, "AF-C" },
{ 4, N_("Permanent-AF") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony AF mode values to readable labels
extern const TagDetails sonyAFMode[] = {
{ 0, N_("Default") },
{ 1, N_("Multi AF") },
{ 2, N_("Center AF") },
{ 3, N_("Spot AF") },
{ 4, N_("Flexible Spot AF") },
{ 6, N_("Touch AF") },
{ 14, N_("Manual Focus") },
{ 15, N_("Face Detected") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony AF illuminator values to readable labels
extern const TagDetails sonyAFIlluminator[] = {
{ 0, N_("Off") },
{ 1, N_("Auto") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony macro mode values to readable labels
extern const TagDetails sonyMacroMode[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("Close Focus") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony flash level values to readable labels
extern const TagDetails sonyFlashLevel[] = {
{ -32768, N_("Low") },
{ -1, N_("n/a") },
{ 0, N_("Normal") },
{ 32767, N_("High") }
};
//! Lookup table to translate Sony release mode values to readable labels
extern const TagDetails sonyReleaseMode[] = {
{ 0, N_("Normal") },
{ 2, N_("Burst") },
{ 5, N_("Exposure Bracketing") },
{ 6, N_("White Balance Bracketing") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony sequence number values to readable labels
extern const TagDetails sonySequenceNumber[] = {
{ 0, N_("Single") },
{ 65535, N_("n/a") }
};
//! Lookup table to translate Sony long exposure noise reduction values to readable labels
extern const TagDetails sonyLongExposureNoiseReduction[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 65535, N_("n/a") }
};
std::ostream& SonyMakerNote::print0xb000(std::ostream& os, const Value& value, const ExifData*)
{
if (value.count() != 4)
{
os << "(" << value << ")";
}
else
{
std::string val = value.toString(0) + value.toString(1) + value.toString(2) + value.toString(3);
if (val == "0002") os << "JPEG";
else if (val == "1000") os << "SR2";
else if (val == "2000") os << "ARW 1.0";
else if (val == "3000") os << "ARW 2.0";
else if (val == "3100") os << "ARW 2.1";
else if (val == "3200") os << "ARW 2.2";
else os << "(" << value << ")";
}
return os;
}
std::ostream& SonyMakerNote::printImageSize(std::ostream& os, const Value& value, const ExifData*)
{
if (value.count() == 2)
os << value.toString(0) << " x " << value.toString(1);
else
os << "(" << value << ")";
return os;
}
// Sony MakerNote Tag Info
const TagInfo SonyMakerNote::tagInfo_[] = {
TagInfo(0x0102, "Quality", N_("Image Quality"),
N_("Image quality"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyImageQuality),
TagInfo(0x0104, "FlashExposureComp", N_("Flash Exposure Compensation"),
N_("Flash exposure compensation in EV"),
sony1Id, makerTags, signedRational, -1, print0x9204),
TagInfo(0x0105, "Teleconverter", N_("Teleconverter Model"),
N_("Teleconverter Model"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyTeleconverterModel),
TagInfo(0x0112, "WhiteBalanceFineTune", N_("White Balance Fine Tune"),
N_("White Balance Fine Tune Value"),
sony1Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0x0114, "CameraSettings", N_("Camera Settings"),
N_("Camera Settings"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x0115, "WhiteBalance", N_("White Balance"),
N_("White balance"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyWhiteBalanceStd),
TagInfo(0x0116, "0x0116", "0x0116",
N_("Unknown"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x0E00, "PrintIM", N_("Print IM"),
N_("PrintIM information"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x1000, "MultiBurstMode", N_("Multi Burst Mode"),
N_("Multi Burst Mode"),
sony1Id, makerTags, undefined, -1, printMinoltaSonyBoolValue),
TagInfo(0x1001, "MultiBurstImageWidth", N_("Multi Burst Image Width"),
N_("Multi Burst Image Width"),
sony1Id, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1002, "MultiBurstImageHeight", N_("Multi Burst Image Height"),
N_("Multi Burst Image Height"),
sony1Id, makerTags, unsignedShort, -1, printValue),
// TODO : Implement Panorama tags decoding.
TagInfo(0x1003, "Panorama", N_("Panorama"),
N_("Panorama"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x2000, "0x2000", "0x2000",
N_("Unknown"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x2001, "PreviewImage", N_("Preview Image"),
N_("JPEG preview image"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0x2002, "0x2002", "0x2002",
N_("Unknown"),
sony1Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0x2003, "0x2003", "0x2003",
N_("Unknown"),
sony1Id, makerTags, asciiString, -1, printValue),
TagInfo(0x2004, "Contrast", "Contrast",
N_("Contrast"),
sony1Id, makerTags, signedLong, -1, printValue),
TagInfo(0x2005, "Saturation", "Saturation",
N_("Saturation"),
sony1Id, makerTags, signedLong, -1, printValue),
TagInfo(0x2006, "0x2006", "0x2006",
N_("Unknown"),
sony1Id, makerTags, signedLong, -1, printValue),
TagInfo(0x2007, "0x2007", "0x2007",
N_("Unknown"),
sony1Id, makerTags, signedLong, -1, printValue),
TagInfo(0x2008, "0x2008", "0x2008",
N_("Unknown"),
sony1Id, makerTags, signedLong, -1, printValue),
TagInfo(0x2009, "0x2009", "0x2009",
N_("Unknown"),
sony1Id, makerTags, unsignedShort, -1, printValue),
TagInfo(0x200A, "AutoHDR", N_("Auto HDR"),
N_("High Definition Range Mode"),
sony1Id, makerTags, unsignedLong, -1, EXV_PRINT_TAG(sonyHDRMode)),
// TODO : Implement Shot Info tags decoding.
TagInfo(0x3000, "ShotInfo", N_("Shot Info"),
N_("Shot Information"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0xB000, "FileFormat", N_("File Format"),
N_("File Format"),
sony1Id, makerTags, unsignedByte, -1, print0xb000),
TagInfo(0xB001, "SonyModelID", N_("Sony Model ID"),
N_("Sony Model ID"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyModelId)),
TagInfo(0xB020, "ColorReproduction", N_("Color Reproduction"),
N_("Color Reproduction"),
sony1Id, makerTags, asciiString, -1, printValue),
TagInfo(0xb021, "ColorTemperature", N_("Color Temperature"),
N_("Color Temperature"),
sony1Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xB022, "ColorCompensationFilter", N_("Color Compensation Filter"),
N_("Color Compensation Filter: negative is green, positive is magenta"),
sony1Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xB023, "SceneMode", N_("Scene Mode"),
N_("Scene Mode"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonySceneMode),
TagInfo(0xB024, "ZoneMatching", N_("Zone Matching"),
N_("Zone Matching"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyZoneMatching),
TagInfo(0xB025, "DynamicRangeOptimizer", N_("Dynamic Range Optimizer"),
N_("Dynamic Range Optimizer"),
sony1Id, makerTags, unsignedLong, -1, EXV_PRINT_TAG(print0xb025)),
TagInfo(0xB026, "ImageStabilization", N_("Image Stabilization"),
N_("Image stabilization"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyBoolValue),
TagInfo(0xB027, "LensID", N_("Lens ID"),
N_("Lens identifier"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyLensID),
TagInfo(0xB028, "MinoltaMakerNote", N_("Minolta MakerNote"),
N_("Minolta MakerNote"),
sony1Id, makerTags, undefined, -1, printValue),
TagInfo(0xB029, "ColorMode", N_("Color Mode"),
N_("Color Mode"),
sony1Id, makerTags, unsignedLong, -1, printMinoltaSonyColorMode),
TagInfo(0xB02B, "FullImageSize", N_("Full Image Size"),
N_("Full Image Size"),
sony1Id, makerTags, unsignedLong, -1, printImageSize),
TagInfo(0xB02C, "PreviewImageSize", N_("Preview Image Size"),
N_("Preview image size"),
sony1Id, makerTags, unsignedLong, -1, printImageSize),
TagInfo(0xB040, "Macro", N_("Macro"),
N_("Macro"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyMacroMode)),
TagInfo(0xB041, "ExposureMode", N_("Exposure Mode"),
N_("Exposure Mode"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyExposureMode)),
TagInfo(0xB042, "FocusMode", N_("Focus Mode"),
N_("Focus Mode"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyFocusMode)),
TagInfo(0xB043, "AFMode", N_("AF Mode"),
N_("AF Mode"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyAFMode)),
TagInfo(0xB044, "AFIlluminator", N_("AF Illuminator"),
N_("AF Illuminator"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyAFIlluminator)),
TagInfo(0xB047, "JPEGQuality", N_("JPEG Quality"),
N_("JPEG Quality"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyJPEGQuality)),
TagInfo(0xB048, "FlashLevel", N_("Flash Level"),
N_("Flash Level"),
sony1Id, makerTags, signedShort, -1, EXV_PRINT_TAG(sonyFlashLevel)),
TagInfo(0xB049, "ReleaseMode", N_("Release Mode"),
N_("Release Mode"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyReleaseMode)),
TagInfo(0xB04A, "SequenceNumber", N_("Sequence Number"),
N_("Shot number in continous burst mode"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonySequenceNumber)),
TagInfo(0xB04B, "AntiBlur", N_("Anti-Blur"),
N_("Anti-Blur"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyAntiBlur)),
TagInfo(0xB04E, "LongExposureNoiseReduction", N_("Long Exposure Noise Reduction"),
N_("Long Exposure Noise Reduction"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyLongExposureNoiseReduction)),
TagInfo(0xB04F, "DynamicRangeOptimizer", N_("Dynamic Range Optimizer"),
N_("Dynamic Range Optimizer"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(print0xb04f)),
TagInfo(0xB052, "IntelligentAuto", N_("Intelligent Auto"),
N_("Intelligent Auto"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyIntelligentAuto)),
TagInfo(0xB054, "WhiteBalance2", N_("White Balance 2"),
N_("White balance 2"),
sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyWhiteBalance)),
// End of list marker
TagInfo(0xffff, "(UnknownSony1MakerNoteTag)", "(UnknownSony1MakerNoteTag)",
N_("Unknown Sony1MakerNote tag"),
sony1Id, makerTags, asciiString, -1, printValue)
};
const TagInfo* SonyMakerNote::tagList()
{
return tagInfo_;
}
// -- Sony camera settings ---------------------------------------------------------------
//! Lookup table to translate Sony camera settings drive mode values to readable labels
extern const TagDetails sonyDriveModeStd[] = {
{ 1, N_("Single Frame") },
{ 2, N_("Continuous High") },
{ 4, N_("Self-timer 10 sec") },
{ 5, N_("Self-timer 2 sec") },
{ 7, N_("Continuous Bracketing") },
{ 12, N_("Continuous Low") },
{ 18, N_("White Balance Bracketing Low") },
{ 19, N_("D-Range Optimizer Bracketing Low") },
{ 19, N_("D-Range Optimizer Bracketing Low") } // To silence compiler warning
};
//! Lookup table to translate Sony camera settings focus mode values to readable labels
extern const TagDetails sonyCSFocusMode[] = {
{ 0, N_("Manual") },
{ 1, "AF-S" },
{ 2, "AF-C" },
{ 3, "AF-A" }
};
//! Lookup table to translate Sony camera settings metering mode values to readable labels
extern const TagDetails sonyMeteringMode[] = {
{ 1, N_("Multi-segment") },
{ 2, N_("Center weighted average") },
{ 4, N_("Spot") }
};
//! Lookup table to translate Sony camera settings creative style values to readable labels
extern const TagDetails sonyCreativeStyle[] = {
{ 1, N_("Standard") },
{ 2, N_("Vivid") },
{ 3, N_("Portrait") },
{ 4, N_("Landscape") },
{ 5, N_("Sunset") },
{ 6, N_("Night View/Portrait") },
{ 8, N_("Black & White") },
{ 9, N_("Adobe RGB") },
{ 11, N_("Neutral") },
{ 12, N_("Clear") },
{ 13, N_("Deep") },
{ 14, N_("Light") },
{ 15, N_("Autumn") },
{ 16, N_("Sepia") }
};
//! Lookup table to translate Sony camera settings flash mode values to readable labels
extern const TagDetails sonyFlashMode[] = {
{ 0, N_("ADI") },
{ 1, N_("TTL") },
};
//! Lookup table to translate Sony AF illuminator values to readable labels
extern const TagDetails sonyAFIlluminatorCS[] = {
{ 0, N_("Auto") },
{ 1, N_("Off") }
};
//! Lookup table to translate Sony camera settings image style values to readable labels
extern const TagDetails sonyImageStyle[] = {
{ 1, N_("Standard") },
{ 2, N_("Vivid") },
{ 9, N_("Adobe RGB") },
{ 11, N_("Neutral") },
{ 129, N_("StyleBox1") },
{ 130, N_("StyleBox1") },
{ 131, N_("StyleBox1") }
};
//! Lookup table to translate Sony camera settings exposure program values to readable labels
extern const TagDetails sonyExposureProgram[] = {
{ 0, N_("Auto") },
{ 1, N_("Manual") },
{ 2, N_("Program AE") },
{ 3, N_("Aperture-priority AE") },
{ 4, N_("Shutter speed priority AE") },
{ 8, N_("Program Shift A") },
{ 9, N_("Program Shift S") },
{ 16, N_("Portrait") },
{ 17, N_("Sports") },
{ 18, N_("Sunset") },
{ 19, N_("Night Portrait") },
{ 20, N_("Landscape") },
{ 21, N_("Macro") },
{ 35, N_("Auto No Flash") }
};
//! Lookup table to translate Sony camera settings image size values to readable labels
extern const TagDetails sonyImageSize[] = {
{ 1, N_("Large") },
{ 2, N_("Medium") },
{ 3, N_("Small") }
};
//! Lookup table to translate Sony aspect ratio values to readable labels
extern const TagDetails sonyAspectRatio[] = {
{ 1, "3:2" },
{ 2, "16:9" }
};
//! Lookup table to translate Sony exposure level increments values to readable labels
extern const TagDetails sonyExposureLevelIncrements[] = {
{ 33, "1/3 EV" },
{ 50, "1/2 EV" }
};
// Sony Camera Settings Tag Info
// NOTE: all are for A200, A230, A300, A350, A700, A850 and A900 Sony model excepted
// some entries which are only relevant with A700.
// Warnings: Exiftool database give a list of tags shorted in decimal mode, not hexadecimal.
const TagInfo SonyMakerNote::tagInfoCs_[] = {
// NOTE: A700 only
TagInfo(0x0004, "DriveMode", N_("Drive Mode"),
N_("Drive Mode"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyDriveModeStd)),
// NOTE: A700 only
TagInfo(0x0006, "WhiteBalanceFineTune", N_("White Balance Fine Tune"),
N_("White Balance Fine Tune"),
sony1CsId, makerTags, signedShort, 1, printValue),
TagInfo(0x0010, "FocusMode", N_("Focus Mode"),
N_("Focus Mode"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyCSFocusMode)),
TagInfo(0x0011, "AFAreaMode", N_("AF Area Mode"),
N_("AF Area Mode"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyAFAreaMode),
TagInfo(0x0012, "LocalAFAreaPoint", N_("Local AF Area Point"),
N_("Local AF Area Point"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyLocalAFAreaPoint),
TagInfo(0x0015, "MeteringMode", N_("Metering Mode"),
N_("Metering Mode"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyMeteringMode)),
TagInfo(0x0016, "ISOSetting", N_("ISO Setting"),
N_("ISO Setting"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0018, "DynamicRangeOptimizerMode", N_("Dynamic Range Optimizer Mode"),
N_("Dynamic Range Optimizer Mode"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyDynamicRangeOptimizerMode),
TagInfo(0x0019, "DynamicRangeOptimizerLevel", N_("Dynamic Range Optimizer Level"),
N_("Dynamic Range Optimizer Level"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001A, "CreativeStyle", N_("Creative Style"),
N_("Creative Style"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyCreativeStyle)),
TagInfo(0x001C, "Sharpness", N_("Sharpness"),
N_("Sharpness"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001D, "Contrast", N_("Contrast"),
N_("Contrast"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001E, "Saturation", N_("Saturation"),
N_("Saturation"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001F, "ZoneMatchingValue", N_("Zone Matching Value"),
N_("Zone Matching Value"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0022, "Brightness", N_("Brightness"),
N_("Brightness"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0023, "FlashMode", N_("FlashMode"),
N_("FlashMode"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyFlashMode)),
// NOTE: A700 only
TagInfo(0x0028, "PrioritySetupShutterRelease", N_("Priority Setup Shutter Release"),
N_("Priority Setup Shutter Release"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyPrioritySetupShutterRelease),
// NOTE: A700 only
TagInfo(0x0029, "AFIlluminator", N_("AF Illuminator"),
N_("AF Illuminator"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyAFIlluminatorCS)),
// NOTE: A700 only
TagInfo(0x002A, "AFWithShutter", N_("AF With Shutter"),
N_("AF With Shutter"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyBoolInverseValue),
// NOTE: A700 only
TagInfo(0x002B, "LongExposureNoiseReduction", N_("Long Exposure Noise Reduction"),
N_("Long Exposure Noise Reduction"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyBoolValue),
// NOTE: A700 only
TagInfo(0x002C, "HighISONoiseReduction", N_("High ISO NoiseReduction"),
N_("High ISO NoiseReduction"),
sony1CsId, makerTags, unsignedShort, 1, printValue),
// NOTE: A700 only
TagInfo(0x002D, "ImageStyle", N_("Image Style"),
N_("Image Style"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyImageStyle)),
TagInfo(0x003C, "ExposureProgram", N_("Exposure Program"),
N_("Exposure Program"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyExposureProgram)),
TagInfo(0x003D, "ImageStabilization", N_("Image Stabilization"),
N_("Image Stabilization"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyBoolValue),
TagInfo(0x003F, "Rotation", N_("Rotation"),
N_("Rotation"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyRotation),
TagInfo(0x0054, "SonyImageSize", N_("Sony Image Size"),
N_("Sony Image Size"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyImageSize)),
TagInfo(0x0055, "AspectRatio", N_("Aspect Ratio"),
N_("Aspect Ratio"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyAspectRatio)),
TagInfo(0x0056, "Quality", N_("Quality"),
N_("Quality"),
sony1CsId, makerTags, unsignedShort, 1, printMinoltaSonyQualityCs),
TagInfo(0x0058, "ExposureLevelIncrements", N_("Exposure Level Increments"),
N_("Exposure Level Increments"),
sony1CsId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyExposureLevelIncrements)),
// End of list marker
TagInfo(0xffff, "(UnknownSony1CsTag)", "(UnknownSony1CsTag)",
N_("Unknown Sony1 Camera Settings tag"),
sony1CsId, makerTags, unsignedShort, 1, printValue)
};
const TagInfo* SonyMakerNote::tagListCs()
{
return tagInfoCs_;
}
// -- Sony camera settings 2 ---------------------------------------------------------------
// Sony Camera Settings Tag Version 2 Info
// NOTE: for A330, A380, A450, A500, A550 Sony model
// Warnings: Exiftool database give a list of tags shorted in decimal mode, not hexadecimal.
const TagInfo SonyMakerNote::tagInfoCs2_[] = {
TagInfo(0x0010, "FocusMode", N_("Focus Mode"),
N_("Focus Mode"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyCSFocusMode)),
TagInfo(0x0011, "AFAreaMode", N_("AF Area Mode"),
N_("AF Area Mode"),
sony1Cs2Id, makerTags, unsignedShort, 1, printMinoltaSonyAFAreaMode),
TagInfo(0x0012, "LocalAFAreaPoint", N_("Local AF Area Point"),
N_("Local AF Area Point"),
sony1Cs2Id, makerTags, unsignedShort, 1, printMinoltaSonyLocalAFAreaPoint),
TagInfo(0x0013, "MeteringMode", N_("Metering Mode"),
N_("Metering Mode"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyMeteringMode)),
TagInfo(0x0014, "ISOSetting", N_("ISO Setting"),
N_("ISO Setting"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0016, "DynamicRangeOptimizerMode", N_("Dynamic Range Optimizer Mode"),
N_("Dynamic Range Optimizer Mode"),
sony1Cs2Id, makerTags, unsignedShort, 1, printMinoltaSonyDynamicRangeOptimizerMode),
TagInfo(0x0017, "DynamicRangeOptimizerLevel", N_("Dynamic Range Optimizer Level"),
N_("Dynamic Range Optimizer Level"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0018, "CreativeStyle", N_("Creative Style"),
N_("Creative Style"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyCreativeStyle)),
TagInfo(0x0019, "Sharpness", N_("Sharpness"),
N_("Sharpness"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001A, "Contrast", N_("Contrast"),
N_("Contrast"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue),
TagInfo(0x001B, "Saturation", N_("Saturation"),
N_("Saturation"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0023, "FlashMode", N_("FlashMode"),
N_("FlashMode"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyFlashMode)),
TagInfo(0x003C, "ExposureProgram", N_("Exposure Program"),
N_("Exposure Program"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyExposureProgram)),
TagInfo(0x003F, "Rotation", N_("Rotation"),
N_("Rotation"),
sony1Cs2Id, makerTags, unsignedShort, 1, printMinoltaSonyRotation),
TagInfo(0x0054, "SonyImageSize", N_("Sony Image Size"),
N_("Sony Image Size"),
sony1Cs2Id, makerTags, unsignedShort, 1, EXV_PRINT_TAG(sonyImageSize)),
// End of list marker
TagInfo(0xffff, "(UnknownSony1Cs2Tag)", "(UnknownSony1Cs2Tag)",
N_("Unknown Sony1 Camera Settings 2 tag"),
sony1Cs2Id, makerTags, unsignedShort, 1, printValue)
};
const TagInfo* SonyMakerNote::tagListCs2()
{
return tagInfoCs2_;
}
}} // namespace Internal, Exiv2
namespace Exiv2 {
//! @cond IGNORE
FujiMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("FUJIFILM", "*", createFujiMakerNote);
MakerNoteFactory::registerMakerNote(
fujiIfdId, MakerNote::AutoPtr(new FujiMakerNote));
ExifTags::registerMakerTagInfo(fujiIfdId, tagInfo_);
}
//! @endcond
// Fujifilm MakerNote Tag Info
const TagInfo FujiMakerNote::tagInfo_[] = {
TagInfo(0x0000, "Version", "Version", "Fujifilm Makernote version", fujiIfdId, makerTags, undefined, printValue),
TagInfo(0x1000, "Quality", "Quality", "Image quality setting", fujiIfdId, makerTags, asciiString, printValue),
TagInfo(0x1001, "Sharpness", "Sharpness", "Sharpness setting", fujiIfdId, makerTags, unsignedShort, print0x1001),
TagInfo(0x1002, "WhiteBalance", "WhiteBalance", "White balance setting", fujiIfdId, makerTags, unsignedShort, print0x1002),
TagInfo(0x1003, "Color", "Color", "Chroma saturation setting", fujiIfdId, makerTags, unsignedShort, print0x1003),
TagInfo(0x1004, "Tone", "Tone", "Contrast setting", fujiIfdId, makerTags, unsignedShort, print0x1004),
TagInfo(0x1010, "FlashMode", "FlashMode", "Flash firing mode setting", fujiIfdId, makerTags, unsignedShort, print0x1010),
TagInfo(0x1011, "FlashStrength", "FlashStrength", "Flash firing strength compensation setting", fujiIfdId, makerTags, signedRational, printValue),
TagInfo(0x1020, "Macro", "Macro", "Macro mode setting", fujiIfdId, makerTags, unsignedShort, printOffOn),
TagInfo(0x1021, "FocusMode", "FocusMode", "Focusing mode setting", fujiIfdId, makerTags, unsignedShort, print0x1021),
TagInfo(0x1022, "0x1022", "0x1022", "Unknown", fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1030, "SlowSync", "SlowSync", "Slow synchro mode setting", fujiIfdId, makerTags, unsignedShort, printOffOn),
TagInfo(0x1031, "PictureMode", "PictureMode", "Picture mode setting", fujiIfdId, makerTags, unsignedShort, print0x1031),
TagInfo(0x1032, "0x1032", "0x1032", "Unknown", fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1100, "Continuous", "Continuous", "Continuous shooting or auto bracketing setting", fujiIfdId, makerTags, unsignedShort, printOffOn),
TagInfo(0x1101, "0x1101", "0x1101", "Unknown", fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1200, "0x1200", "0x1200", "Unknown", fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1300, "BlurWarning", "BlurWarning", "Blur warning status", fujiIfdId, makerTags, unsignedShort, printOffOn),
TagInfo(0x1301, "FocusWarning", "FocusWarning", "Auto Focus warning status", fujiIfdId, makerTags, unsignedShort, printOffOn),
TagInfo(0x1302, "AeWarning", "AeWarning", "Auto Exposure warning status", fujiIfdId, makerTags, unsignedShort, printOffOn),
// End of list marker
TagInfo(0xffff, "(UnknownFujiMakerNoteTag)", "(UnknownFujiMakerNoteTag)", "Unknown FujiMakerNote tag", fujiIfdId, makerTags, invalidTypeId, printValue)
};
FujiMakerNote::FujiMakerNote(bool alloc)
: IfdMakerNote(fujiIfdId, alloc)
{
byteOrder_ = littleEndian;
absShift_ = false;
byte buf[] = {
'F', 'U', 'J', 'I', 'F', 'I', 'L', 'M', 0x0c, 0x00, 0x00, 0x00
};
readHeader(buf, 12, byteOrder_);
}
FujiMakerNote::FujiMakerNote(const FujiMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int FujiMakerNote::readHeader(const byte* buf,
long len,
ByteOrder byteOrder)
{
if (len < 12) return 1;
header_.alloc(12);
memcpy(header_.pData_, buf, header_.size_);
// Read offset to the IFD relative to the start of the makernote
// from the header. Note that we ignore the byteOrder paramter
start_ = getUShort(header_.pData_ + 8, byteOrder_);
return 0;
}
int FujiMakerNote::checkHeader() const
{
int rc = 0;
// Check the FUJIFILM prefix
if ( header_.size_ < 12
|| std::string(reinterpret_cast<char*>(header_.pData_), 8)
!= std::string("FUJIFILM", 8)) {
rc = 2;
}
return rc;
}
FujiMakerNote::AutoPtr FujiMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
FujiMakerNote* FujiMakerNote::create_(bool alloc) const
{
AutoPtr makerNote = AutoPtr(new FujiMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
FujiMakerNote::AutoPtr FujiMakerNote::clone() const
{
return AutoPtr(clone_());
}
FujiMakerNote* FujiMakerNote::clone_() const
{
return new FujiMakerNote(*this);
}
std::ostream& FujiMakerNote::printOffOn(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Off"; break;
case 1: os << "On"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1001(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 1: // fallthrough
case 2: os << "Soft"; break;
case 3: os << "Normal"; break;
case 4: // fallthrough
case 5: os << "Hard"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1002(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Auto"; break;
case 256: os << "Daylight"; break;
case 512: os << "Cloudy"; break;
case 768: os << "Fluorescent (daylight)"; break;
case 769: os << "Fluorescent (warm white)"; break;
case 770: os << "Fluorescent (cool white)"; break;
case 1024: os << "Incandescent"; break;
case 3480: os << "Custom"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1003(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Standard"; break;
case 256: os << "High"; break;
case 512: os << "Original"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1004(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Standard"; break;
case 256: os << "Hard"; break;
case 512: os << "Original"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1010(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Auto"; break;
case 1: os << "On"; break;
case 2: os << "Off"; break;
case 3: os << "Red-eye"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1021(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Auto"; break;
case 1: os << "Manual"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& FujiMakerNote::print0x1031(std::ostream& os,
const Value& value)
{
switch (value.toLong()) {
case 0: os << "Auto"; break;
case 1: os << "Portrait"; break;
case 2: os << "Landscape"; break;
case 4: os << "Sports"; break;
case 5: os << "Night"; break;
case 6: os << "Program"; break;
case 256: os << "Aperture priority"; break;
case 512: os << "Shutter priority"; break;
case 768: os << "Manual"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
// *****************************************************************************
// free functions
MakerNote::AutoPtr createFujiMakerNote(bool alloc,
const byte* buf,
long len,
ByteOrder byteOrder,
long offset)
{
return MakerNote::AutoPtr(new FujiMakerNote(alloc));
}
} // namespace Exiv2
namespace Internal {
//! LensType, tag 0xa003
extern const TagDetails samsung2LensType[] = {
{ 0, N_("Built-in") },
{ 1, N_("Samsung NX 30mm F2 Pancake") },
{ 2, N_("Samsung NX 18-55mm F3.5-5.6 OIS") },
{ 3, N_("Samsung NX 50-200mm F4-5.6 ED OIS") },
{ 4, N_("Samsung NX 20-50mm F3.5-5.6 ED") },
{ 6, N_("Samsung NX 18-200mm F3.5-6.3 ED OIS") },
{ 5, N_("Samsung NX 20mm F2.8 Pancake") },
{ 7, N_("Samsung NX 60mm F2.8 Macro ED OIS SSA") },
{ 8, N_("Samsung NX 16mm F2.4 Pancake") },
{ 9, N_("Samsung NX 85mm F1.4 ED SSA") },
{ 10, N_("Samsung NX 45mm F1.8") },
{ 11, N_("Samsung NX 45mm F1.8 2D/3D") },
{ 12, N_("Samsung NX 12-24mm F4-5.6 ED") }
};
//! ColorSpace, tag 0xa011
extern const TagDetails samsung2ColorSpace[] = {
{ 0, N_("sRGB") },
{ 1, N_("Adobe RGB") }
};
//! SmartRange, tag 0xa012
extern const TagDetails samsung2SmartRange[] = {
{ 0, N_("Off") },
{ 1, N_("On") }
};
//! Print the camera temperature
std::ostream& printCameraTemperature(std::ostream& os, const Value& value, const ExifData*)
{
if (value.count() != 1 || value.typeId() != signedRational) {
return os << value;
}
return os << value.toFloat() << " C";
}
//! Print the 35mm focal length
std::ostream& printFocalLength35(std::ostream& os, const Value& value, const ExifData*)
{
if (value.count() != 1 || value.typeId() != unsignedLong) {
return os << value;
}
long length = value.toLong();
if (length == 0) {
os << _("Unknown");
}
else {
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1) << length / 10.0 << " mm";
os.copyfmt(oss);
}
return os;
}
// Samsung MakerNote Tag Info
const TagInfo Samsung2MakerNote::tagInfo_[] = {
TagInfo(0x0001, "Version", N_("Version"), N_("Makernote version"), samsung2Id, makerTags, undefined, -1, printExifVersion),
TagInfo(0x0021, "PictureWizard", N_("Picture Wizard"), N_("Picture wizard composite tag"), samsung2Id, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0030, "LocalLocationName", N_("Local Location Name"), N_("Local location name"), samsung2Id, makerTags, asciiString, -1, printValue),
TagInfo(0x0031, "LocationName", N_("Location Name"), N_("Location name"), samsung2Id, makerTags, asciiString, -1, printValue),
TagInfo(0x0035, "Preview", N_("Pointer to a preview image"), N_("Offset to an IFD containing a preview image"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0x0043, "CameraTemperature", N_("Camera Temperature"), N_("Camera temperature"), samsung2Id, makerTags, signedRational, -1, printCameraTemperature),
TagInfo(0xa001, "FirmwareName", N_("Firmware Name"), N_("Firmware name"), samsung2Id, makerTags, asciiString, -1, printValue),
TagInfo(0xa003, "LensType", N_("Lens Type"), N_("Lens type"), samsung2Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(samsung2LensType)),
TagInfo(0xa004, "LensFirmware", N_("Lens Firmware"), N_("Lens firmware"), samsung2Id, makerTags, asciiString, -1, printValue),
TagInfo(0xa010, "SensorAreas", N_("Sensor Areas"), N_("Sensor areas"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa011, "ColorSpace", N_("Color Space"), N_("Color space"), samsung2Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(samsung2ColorSpace)),
TagInfo(0xa012, "SmartRange", N_("Smart Range"), N_("Smart range"), samsung2Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(samsung2SmartRange)),
TagInfo(0xa013, "ExposureBiasValue", N_("Exposure Bias Value"), N_("Exposure bias value"), samsung2Id, makerTags, signedRational, -1, print0x9204),
TagInfo(0xa014, "ISO", N_("ISO"), N_("ISO"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa018, "ExposureTime", N_("Exposure Time"), N_("Exposure time"), samsung2Id, makerTags, unsignedRational, -1, print0x829a),
TagInfo(0xa019, "FNumber", N_("FNumber"), N_("The F number."), samsung2Id, makerTags, unsignedRational, -1, print0x829d),
TagInfo(0xa01a, "FocalLengthIn35mmFormat", N_("Focal Length In 35mm Format"), N_("Focal length in 35mm format"), samsung2Id, makerTags, unsignedLong, -1, printFocalLength35),
TagInfo(0xa020, "EncryptionKey", N_("Encryption Key"), N_("Encryption key"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa021, "WB_RGGBLevelsUncorrected", N_("WB RGGB Levels Uncorrected"), N_("WB RGGB levels not corrected for WB_RGGBLevelsBlack"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa022, "WB_RGGBLevelsAuto", N_("WB RGGB Levels Auto"), N_("WB RGGB levels auto"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa023, "WB_RGGBLevelsIlluminator1", N_("WB RGGB Levels Illuminator1"), N_("WB RGGB levels illuminator1"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa024, "WB_RGGBLevelsIlluminator2", N_("WB RGGB Levels Illuminator2"), N_("WB RGGB levels illuminator2"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa028, "WB_RGGBLevelsBlack", N_("WB RGGB Levels Black"), N_("WB RGGB levels black"), samsung2Id, makerTags, signedLong, -1, printValue),
TagInfo(0xa030, "ColorMatrix", N_("Color Matrix"), N_("Color matrix"), samsung2Id, makerTags, signedLong, -1, printValue),
TagInfo(0xa031, "ColorMatrixSRGB", N_("Color Matrix sRGB"), N_("Color matrix sRGB"), samsung2Id, makerTags, signedLong, -1, printValue),
TagInfo(0xa032, "ColorMatrixAdobeRGB", N_("Color Matrix Adobe RGB"), N_("Color matrix Adobe RGB"), samsung2Id, makerTags, signedLong, -1, printValue),
TagInfo(0xa040, "ToneCurve1", N_("Tone Curve 1"), N_("Tone curve 1"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa041, "ToneCurve2", N_("Tone Curve 2"), N_("Tone curve 2"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa042, "ToneCurve3", N_("Tone Curve 3"), N_("Tone curve 3"), samsung2Id, makerTags, unsignedLong, -1, printValue),
TagInfo(0xa043, "ToneCurve4", N_("Tone Curve 4"), N_("Tone curve 4"), samsung2Id, makerTags, unsignedLong, -1, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownSamsung2MakerNoteTag)", "(UnknownSamsung2MakerNoteTag)", N_("Unknown Samsung2MakerNote tag"), samsung2Id, makerTags, undefined, -1, printValue)
};
const TagInfo* Samsung2MakerNote::tagList()
{
return tagInfo_;
}
//! PictureWizard Mode
extern const TagDetails samsungPwMode[] = {
{ 0, N_("Standard") },
{ 1, N_("Vivid") },
{ 2, N_("Portrait") },
{ 3, N_("Landscape") },
{ 4, N_("Forest") },
{ 5, N_("Retro") },
{ 6, N_("Cool") },
{ 7, N_("Calm") },
{ 8, N_("Classic") },
{ 9, N_("Custom1") },
{ 10, N_("Custom2") },
{ 11, N_("Custom3") }
};
//! Print the tag value minus 4
std::ostream& printValueMinus4(std::ostream& os, const Value& value, const ExifData*)
{
if (value.count() != 1 || value.typeId() != unsignedShort) {
return os << value;
}
return os << value.toLong(0) - 4;
}
// Samsung PictureWizard Tag Info
const TagInfo Samsung2MakerNote::tagInfoPw_[] = {
TagInfo(0x0000, "Mode", N_("Mode"), N_("Mode"), samsungPwId, makerTags, unsignedShort, 1, EXV_PRINT_TAG(samsungPwMode)),
TagInfo(0x0001, "Color", N_("Color"), N_("Color"), samsungPwId, makerTags, unsignedShort, 1, printValue),
TagInfo(0x0002, "Saturation", N_("Saturation"), N_("Saturation"), samsungPwId, makerTags, unsignedShort, 1, printValueMinus4),
TagInfo(0x0003, "Sharpness", N_("Sharpness"), N_("Sharpness"), samsungPwId, makerTags, unsignedShort, 1, printValueMinus4),
TagInfo(0x0004, "Contrast", N_("Contrast"), N_("Contrast"), samsungPwId, makerTags, unsignedShort, 1, printValueMinus4),
// End of list marker
TagInfo(0xffff, "(UnknownSamsungPictureWizardTag)", "(UnknownSamsungPictureWizardTag)", N_("Unknown SamsungPictureWizard tag"), samsungPwId, makerTags, unsignedShort, 1, printValue)
};
const TagInfo* Samsung2MakerNote::tagListPw()
{
return tagInfoPw_;
}
}} // namespace Internal, Exiv2
namespace Exiv2 {
//! @cond IGNORE
FujiMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("FUJIFILM", "*", createFujiMakerNote);
MakerNoteFactory::registerMakerNote(
fujiIfdId, MakerNote::AutoPtr(new FujiMakerNote));
ExifTags::registerMakerTagInfo(fujiIfdId, tagInfo_);
}
//! @endcond
//! OffOn, multiple tags
extern const TagDetails fujiOffOn[] = {
{ 0, N_("Off") },
{ 1, N_("On") }
};
//! Sharpness, tag 0x1001
extern const TagDetails fujiSharpness[] = {
{ 1, N_("Soft mode 1") },
{ 2, N_("Soft mode 2") },
{ 3, N_("Normal") },
{ 4, N_("Hard mode 1") },
{ 5, N_("Hard mode 2") }
};
//! WhiteBalance, tag 0x1002
extern const TagDetails fujiWhiteBalance[] = {
{ 0, N_("Auto") },
{ 256, N_("Daylight") },
{ 512, N_("Cloudy") },
{ 768, N_("Fluorescent (daylight)") },
{ 769, N_("Fluorescent (warm white)") },
{ 770, N_("Fluorescent (cool white)") },
{ 1024, N_("Incandescent") },
{ 3480, N_("Custom") }
};
//! Color, tag 0x1003
extern const TagDetails fujiColor[] = {
{ 0, N_("Normal") },
{ 256, N_("High") },
{ 512, N_("Low") },
{ 768, N_("None (black & white)") }
};
//! Tone, tag 0x1004
extern const TagDetails fujiTone[] = {
{ 0, N_("Normal") },
{ 256, N_("High") },
{ 512, N_("Low") }
};
//! FlashMode, tag 0x1010
extern const TagDetails fujiFlashMode[] = {
{ 0, N_("Auto") },
{ 1, N_("On") },
{ 2, N_("Off") },
{ 3, N_("Red-eye reduction") }
};
//! FocusMode, tag 0x1021
extern const TagDetails fujiFocusMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Manual") }
};
//! PictureMode, tag 0x1031
extern const TagDetails fujiPictureMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Portrait") },
{ 2, N_("Landscape") },
{ 4, N_("Sports") },
{ 5, N_("Night scene") },
{ 6, N_("Program AE") },
{ 7, N_("Natural light") },
{ 8, N_("Anti-blur") },
{ 10, N_("Sunset") },
{ 11, N_("Museum") },
{ 12, N_("Party") },
{ 13, N_("Flower") },
{ 14, N_("Text") },
{ 15, N_("Natural light & flash") },
{ 16, N_("Beach") },
{ 17, N_("Snow") },
{ 18, N_("Fireworks") },
{ 19, N_("Underwater") },
{ 256, N_("Aperture-priority AE") },
{ 512, N_("Shutter speed priority AE") },
{ 768, N_("Manual") }
};
//! Continuous, tag 0x1100
extern const TagDetails fujiContinuous[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("No flash & flash") }
};
//! FinePixColor, tag 0x1210
extern const TagDetails fujiFinePixColor[] = {
{ 0, N_("Standard") },
{ 16, N_("Chrome") },
{ 48, N_("Black & white") }
};
//! DynamicRange, tag 0x1400
extern const TagDetails fujiDynamicRange[] = {
{ 1, N_("Standard") },
{ 3, N_("Wide") }
};
//! FilmMode, tag 0x1401
extern const TagDetails fujiFilmMode[] = {
{ 0, N_("F0/Standard") },
{ 256, N_("F1/Studio portrait") },
{ 512, N_("F2/Fujichrome") },
{ 768, N_("F3/Studio portrait Ex") },
{ 1024, N_("F4/Velvia") }
};
//! DynamicRange, tag 0x1402
extern const TagDetails fujiDynamicRangeSetting[] = {
{ 0, N_("Auto (100-400%)") },
{ 1, N_("Raw") },
{ 256, N_("Standard (100%)") },
{ 512, N_("Wide mode 1 (230%)") },
{ 513, N_("Wide mode 2 (400%)") },
{ 32768, N_("Film simulation mode") }
};
// Fujifilm MakerNote Tag Info
const TagInfo FujiMakerNote::tagInfo_[] = {
TagInfo(0x0000, "Version", N_("Version"),
N_("Fujifilm Makernote version"),
fujiIfdId, makerTags, undefined, printValue),
TagInfo(0x0010, "SerialNumber", N_("Serial Number"),
N_("This number is unique, and contains the date of manufacture, "
"but is not the same as the number printed on the camera body."),
fujiIfdId, makerTags, asciiString, printValue),
TagInfo(0x1000, "Quality", N_("Quality"),
N_("Image quality setting"),
fujiIfdId, makerTags, asciiString, printValue),
TagInfo(0x1001, N_("Sharpness"), N_("Sharpness"),
N_("Sharpness setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiSharpness)),
TagInfo(0x1002, "WhiteBalance", N_("White Balance"),
N_("White balance setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiWhiteBalance)),
TagInfo(0x1003, "Color", N_("Color"),
N_("Chroma saturation setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiColor)),
TagInfo(0x1004, "Tone", N_("Tone"),
N_("Contrast setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiTone)),
TagInfo(0x1010, "FlashMode", N_("Flash Mode"),
N_("Flash firing mode setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFlashMode)),
TagInfo(0x1011, "FlashStrength", N_("Flash Strength"),
N_("Flash firing strength compensation setting"),
fujiIfdId, makerTags, signedRational, printValue),
TagInfo(0x1020, "Macro", N_("Macro"),
N_("Macro mode setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1021, "FocusMode", N_("Focus Mode"),
N_("Focusing mode setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFocusMode)),
TagInfo(0x1022, "0x1022", "0x1022",
N_("Unknown"),
fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1030, "SlowSync", N_("Slow Sync"),
N_("Slow synchro mode setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1031, "PictureMode", N_("Picture Mode"),
N_("Picture mode setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiPictureMode)),
TagInfo(0x1032, "0x1032", "0x1032",
N_("Unknown"),
fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1100, "Continuous", N_("Continuous"),
N_("Continuous shooting or auto bracketing setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiContinuous)),
TagInfo(0x1101, "SequenceNumber", N_("Sequence Number"),
N_("Sequence number"),
fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1200, "0x1200", "0x1200",
N_("Unknown"),
fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1210, "FinePixColor", N_("FinePix Color"),
N_("Fuji FinePix color setting"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFinePixColor)),
TagInfo(0x1300, "BlurWarning", N_("Blur Warning"),
N_("Blur warning status"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1301, "FocusWarning", N_("Focus Warning"),
N_("Auto Focus warning status"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1302, "ExposureWarning", N_("Exposure Warning"),
N_("Auto exposure warning status"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1400, "DynamicRange", N_("Dynamic Range"),
N_("Dynamic range"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiDynamicRange)),
TagInfo(0x1401, "FilmMode", N_("Film Mode"),
N_("Film mode"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFilmMode)),
TagInfo(0x1402, "DynamicRangeSetting", N_("Dynamic Range Setting"),
N_("Dynamic range settings"),
fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiDynamicRangeSetting)),
TagInfo(0x1403, "DevelopmentDynamicRange", N_("Development Dynamic Range"),
N_("Development dynamic range"),
fujiIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1404, "MinFocalLength", N_("Minimum Focal Length"),
N_("Minimum focal length"),
fujiIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x1405, "MaxFocalLength", N_("Maximum Focal Length"),
N_("Maximum focal length"),
fujiIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x1406, "MaxApertureAtMinFocal", N_("Maximum Aperture at Mininimum Focal"),
N_("Maximum aperture at mininimum focal"),
fujiIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x1407, "MaxApertureAtMaxFocal", N_("Maximum Aperture at Maxinimum Focal"),
N_("Maximum aperture at maxinimum focal"),
fujiIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x8000, "FileSource", N_("File Source"),
N_("File source"),
fujiIfdId, makerTags, asciiString, printValue),
TagInfo(0x8002, "OrderNumber", N_("Order Number"),
N_("Order number"),
fujiIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x8003, "FrameNumber", N_("Frame Number"),
N_("Frame number"),
fujiIfdId, makerTags, unsignedShort, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownFujiMakerNoteTag)", "(UnknownFujiMakerNoteTag)",
N_("Unknown FujiMakerNote tag"),
fujiIfdId, makerTags, invalidTypeId, printValue)
};
const TagInfo* FujiMakerNote::tagList()
{
return tagInfo_;
}
FujiMakerNote::FujiMakerNote(bool alloc)
: IfdMakerNote(fujiIfdId, alloc)
{
byteOrder_ = littleEndian;
absShift_ = false;
byte buf[] = {
'F', 'U', 'J', 'I', 'F', 'I', 'L', 'M', 0x0c, 0x00, 0x00, 0x00
};
readHeader(buf, 12, byteOrder_);
}
FujiMakerNote::FujiMakerNote(const FujiMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int FujiMakerNote::readHeader(const byte* buf,
long len,
ByteOrder /*byteOrder*/)
{
if (len < 12) return 1;
header_.alloc(12);
std::memcpy(header_.pData_, buf, header_.size_);
// Read offset to the IFD relative to the start of the makernote
// from the header. Note that we ignore the byteOrder paramter
start_ = getUShort(header_.pData_ + 8, byteOrder_);
return 0;
}
int FujiMakerNote::checkHeader() const
{
int rc = 0;
// Check the FUJIFILM prefix
if ( header_.size_ < 12
|| std::string(reinterpret_cast<char*>(header_.pData_), 8)
!= std::string("FUJIFILM", 8)) {
rc = 2;
}
return rc;
}
FujiMakerNote::AutoPtr FujiMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
FujiMakerNote* FujiMakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new FujiMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
FujiMakerNote::AutoPtr FujiMakerNote::clone() const
{
return AutoPtr(clone_());
}
FujiMakerNote* FujiMakerNote::clone_() const
{
return new FujiMakerNote(*this);
}
// *****************************************************************************
// free functions
MakerNote::AutoPtr createFujiMakerNote(bool alloc,
const byte* /*buf*/,
long /*len*/,
ByteOrder /*byteOrder*/,
long /*offset*/)
{
return MakerNote::AutoPtr(new FujiMakerNote(alloc));
}
} // namespace Exiv2
namespace Internal {
//! OffOn, multiple tags
extern const TagDetails fujiOffOn[] = {
{ 0, N_("Off") },
{ 1, N_("On") }
};
//! Sharpness, tag 0x1001
extern const TagDetails fujiSharpness[] = {
{ 1, N_("Soft mode 1") },
{ 2, N_("Soft mode 2") },
{ 3, N_("Normal") },
{ 4, N_("Hard mode 1") },
{ 5, N_("Hard mode 2") }
};
//! WhiteBalance, tag 0x1002
extern const TagDetails fujiWhiteBalance[] = {
{ 0, N_("Auto") },
{ 256, N_("Daylight") },
{ 512, N_("Cloudy") },
{ 768, N_("Fluorescent (daylight)") },
{ 769, N_("Fluorescent (warm white)") },
{ 770, N_("Fluorescent (cool white)") },
{ 1024, N_("Incandescent") },
{ 3480, N_("Custom") },
{ 3480, N_("Custom") } // To silence compiler warning
};
//! Color, tag 0x1003
extern const TagDetails fujiColor[] = {
{ 0, N_("Normal") },
{ 256, N_("High") },
{ 512, N_("Low") },
{ 768, N_("None (black & white)") },
{ 768, N_("None (black & white)") } // To silence compiler warning
};
//! Tone, tag 0x1004
extern const TagDetails fujiTone[] = {
{ 0, N_("Normal") },
{ 256, N_("High") },
{ 512, N_("Low") }
};
//! FlashMode, tag 0x1010
extern const TagDetails fujiFlashMode[] = {
{ 0, N_("Auto") },
{ 1, N_("On") },
{ 2, N_("Off") },
{ 3, N_("Red-eye reduction") },
{ 4, N_("External") },
{ 16, N_("Commander") },
{ 16, N_("Commander") } // To silence compiler warning
};
//! FocusMode, tag 0x1021
extern const TagDetails fujiFocusMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Manual") }
};
//! PictureMode, tag 0x1031
extern const TagDetails fujiPictureMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Portrait") },
{ 2, N_("Landscape") },
{ 4, N_("Sports") },
{ 5, N_("Night scene") },
{ 6, N_("Program AE") },
{ 7, N_("Natural light") },
{ 8, N_("Anti-blur") },
{ 10, N_("Sunset") },
{ 11, N_("Museum") },
{ 12, N_("Party") },
{ 13, N_("Flower") },
{ 14, N_("Text") },
{ 15, N_("Natural light & flash") },
{ 16, N_("Beach") },
{ 17, N_("Snow") },
{ 18, N_("Fireworks") },
{ 19, N_("Underwater") },
{ 256, N_("Aperture-priority AE") },
{ 512, N_("Shutter speed priority AE") },
{ 768, N_("Manual") }
};
//! Continuous, tag 0x1100
extern const TagDetails fujiContinuous[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("No flash & flash") }
};
//! FinePixColor, tag 0x1210
extern const TagDetails fujiFinePixColor[] = {
{ 0, N_("Standard") },
{ 16, N_("Chrome") },
{ 48, N_("Black & white") }
};
//! DynamicRange, tag 0x1400
extern const TagDetails fujiDynamicRange[] = {
{ 1, N_("Standard") },
{ 3, N_("Wide") }
};
//! FilmMode, tag 0x1401
extern const TagDetails fujiFilmMode[] = {
{ 0, N_("F0/Standard (Provia)") },
{ 256, N_("F1/Studio Portrait") },
{ 272, N_("F1a/Studio Portrait Enhanced Saturation") },
{ 288, N_("F1b/Studio Portrait Smooth Skin Tone (Astia)") },
{ 304, N_("F1c/Studio Portrait Increased Sharpness") },
{ 512, N_("F2/Fujichrome (Velvia)") },
{ 768, N_("F3/Studio Portrait Ex") },
{ 1024, N_("F4/Velvia") },
{ 1280, N_("Pro Neg. Std") },
{ 1281, N_("Pro Neg. Hi") },
{ 1536, N_("Classic Chrome") },
};
//! DynamicRange, tag 0x1402
extern const TagDetails fujiDynamicRangeSetting[] = {
{ 0, N_("Auto (100-400%)") },
{ 1, N_("Raw") },
{ 256, N_("Standard (100%)") },
{ 512, N_("Wide mode 1 (230%)") },
{ 513, N_("Wide mode 2 (400%)") },
{ 32768, N_("Film simulation mode") }
};
// Fujifilm MakerNote Tag Info
const TagInfo FujiMakerNote::tagInfo_[] = {
TagInfo(0x0000, "Version", N_("Version"),
N_("Fujifilm Makernote version"),
fujiId, makerTags, undefined, -1, printValue),
TagInfo(0x0010, "SerialNumber", N_("Serial Number"),
N_("This number is unique, and contains the date of manufacture, "
"but is not the same as the number printed on the camera body."),
fujiId, makerTags, asciiString, -1, printValue),
TagInfo(0x1000, "Quality", N_("Quality"),
N_("Image quality setting"),
fujiId, makerTags, asciiString, -1, printValue),
TagInfo(0x1001, N_("Sharpness"), N_("Sharpness"),
N_("Sharpness setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiSharpness)),
TagInfo(0x1002, "WhiteBalance", N_("White Balance"),
N_("White balance setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiWhiteBalance)),
TagInfo(0x1003, "Color", N_("Color"),
N_("Chroma saturation setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiColor)),
TagInfo(0x1004, "Tone", N_("Tone"),
N_("Contrast setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiTone)),
TagInfo(0x1010, "FlashMode", N_("Flash Mode"),
N_("Flash firing mode setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiFlashMode)),
TagInfo(0x1011, "FlashStrength", N_("Flash Strength"),
N_("Flash firing strength compensation setting"),
fujiId, makerTags, signedRational, -1, printValue),
TagInfo(0x1020, "Macro", N_("Macro"),
N_("Macro mode setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1021, "FocusMode", N_("Focus Mode"),
N_("Focusing mode setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiFocusMode)),
TagInfo(0x1022, "0x1022", "0x1022",
N_("Unknown"),
fujiId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1030, "SlowSync", N_("Slow Sync"),
N_("Slow synchro mode setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1031, "PictureMode", N_("Picture Mode"),
N_("Picture mode setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiPictureMode)),
TagInfo(0x1032, "0x1032", "0x1032",
N_("Unknown"),
fujiId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1100, "Continuous", N_("Continuous"),
N_("Continuous shooting or auto bracketing setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiContinuous)),
TagInfo(0x1101, "SequenceNumber", N_("Sequence Number"),
N_("Sequence number"),
fujiId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1200, "0x1200", "0x1200",
N_("Unknown"),
fujiId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1210, "FinePixColor", N_("FinePix Color"),
N_("Fuji FinePix color setting"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiFinePixColor)),
TagInfo(0x1300, "BlurWarning", N_("Blur Warning"),
N_("Blur warning status"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1301, "FocusWarning", N_("Focus Warning"),
N_("Auto Focus warning status"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1302, "ExposureWarning", N_("Exposure Warning"),
N_("Auto exposure warning status"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiOffOn)),
TagInfo(0x1400, "DynamicRange", N_("Dynamic Range"),
N_("Dynamic range"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiDynamicRange)),
TagInfo(0x1401, "FilmMode", N_("Film Mode"),
N_("Film mode"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiFilmMode)),
TagInfo(0x1402, "DynamicRangeSetting", N_("Dynamic Range Setting"),
N_("Dynamic range settings"),
fujiId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(fujiDynamicRangeSetting)),
TagInfo(0x1403, "DevelopmentDynamicRange", N_("Development Dynamic Range"),
N_("Development dynamic range"),
fujiId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x1404, "MinFocalLength", N_("Minimum Focal Length"),
N_("Minimum focal length"),
fujiId, makerTags, unsignedRational, -1, printValue),
TagInfo(0x1405, "MaxFocalLength", N_("Maximum Focal Length"),
N_("Maximum focal length"),
fujiId, makerTags, unsignedRational, -1, printValue),
TagInfo(0x1406, "MaxApertureAtMinFocal", N_("Maximum Aperture at Minimum Focal"),
N_("Maximum aperture at minimum focal"),
fujiId, makerTags, unsignedRational, -1, printValue),
TagInfo(0x1407, "MaxApertureAtMaxFocal", N_("Maximum Aperture at Maximum Focal"),
N_("Maximum aperture at maximum focal"),
fujiId, makerTags, unsignedRational, -1, printValue),
TagInfo(0x8000, "FileSource", N_("File Source"),
N_("File source"),
fujiId, makerTags, asciiString, -1, printValue),
TagInfo(0x8002, "OrderNumber", N_("Order Number"),
N_("Order number"),
fujiId, makerTags, unsignedLong, -1, printValue),
TagInfo(0x8003, "FrameNumber", N_("Frame Number"),
N_("Frame number"),
fujiId, makerTags, unsignedShort, -1, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownFujiMakerNoteTag)", "(UnknownFujiMakerNoteTag)",
N_("Unknown FujiMakerNote tag"),
fujiId, makerTags, asciiString, -1, printValue)
};
const TagInfo* FujiMakerNote::tagList()
{
return tagInfo_;
}
}} // namespace Internal, Exiv2
namespace Exiv2 {
//! OffOn, multiple tags
extern const TagDetails olympusOffOn[] = {
{ 0, N_("Off") },
{ 1, N_("On") }
};
//! Quality, tag 0x0201
extern const TagDetails olympusQuality[] = {
{ 1, N_("Standard Quality (SQ)") },
{ 2, N_("High Quality (HQ)") },
{ 3, N_("Super High Quality (SHQ)") },
{ 6, N_("Raw") }
};
//! Macro, tag 0x0202
extern const TagDetails olympusMacro[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("Super macro") }
};
//! OneTouchWB, tag 0x0302
extern const TagDetails olympusOneTouchWb[] = {
{ 0, N_("Off") },
{ 1, N_("On") },
{ 2, N_("On (preset)") }
};
//! FlashDevice, tag 0x1005
extern const TagDetails olympusFlashDevice[] = {
{ 0, N_("None") },
{ 1, N_("Internal") },
{ 4, N_("External") },
{ 5, N_("Internal + External") }
};
//! FocusMode, tag 0x100b
extern const TagDetails olympusFocusMode[] = {
{ 0, N_("Auto") },
{ 1, N_("Manual") }
};
//! Sharpness, tag 0x100f
extern const TagDetails olympusSharpness[] = {
{ 0, N_("Normal") },
{ 1, N_("Hard") },
{ 2, N_("Soft") }
};
//! Contrast, tag 0x1029
extern const TagDetails olympusContrast[] = {
{ 0, N_("High") },
{ 1, N_("Normal") },
{ 2, N_("Low") }
};
//! CCDScanMode, tag 0x1039
extern const TagDetails olympusCCDScanMode[] = {
{ 0, N_("Interlaced") },
{ 1, N_("Progressive") }
};
// Olympus Tag Info
const TagInfo OlympusMakerNote::tagInfo_[] = {
/* TODO:
add Minolta makenotes tags here (0x0000-0x0103). See Exiftool database.*/
TagInfo(0x0200, "SpecialMode", N_("Special Mode"),
N_("Picture taking mode"),
olympusIfdId, makerTags, unsignedLong, print0x0200),
TagInfo(0x0201, "Quality", N_("Quality"),
N_("Image quality setting"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusQuality)),
TagInfo(0x0202, "Macro", N_("Macro"),
N_("Macro mode"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusMacro)),
TagInfo(0x0203, "BWMode", N_("Black & White Mode"),
N_("Black and white mode"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
TagInfo(0x0204, "DigitalZoom", N_("Digital Zoom"),
N_("Digital zoom ratio"),
olympusIfdId, makerTags, unsignedRational, print0x0204),
TagInfo(0x0205, "FocalPlaneDiagonal", N_("Focal Plane Diagonal"),
N_("Focal plane diagonal"),
olympusIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x0206, "LensDistortionParams", N_("Lens Distortion Parameters"),
N_("Lens distortion parameters"),
olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x0207, "FirmwareVersion", N_("Firmware Version"),
N_("Software firmware version"),
olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0208, "PictureInfo", N_("Picture Info"),
N_("ASCII format data such as [PictureInfo]"),
olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0209, "CameraID", N_("Camera ID"),
N_("Camera ID data"),
olympusIfdId, makerTags, undefined, printValue),
/* TODO: Epson Camera tags. See ExifTool database.
TagInfo(0x020b, "ImageWidth", N_("Image Width"),
N_("Image width"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x020c, "ImageHeight", N_("Image Height"),
N_("Image height"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x020d, "Software", N_("Software"),
N_("Software"),
olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0280, "PreviewImage", N_("Preview Image"),
N_("Preview image"),
olympusIfdId, makerTags, unsignedByte, printValue),
*/
TagInfo(0x0300, "PreCaptureFrames", N_("Pre Capture Frames"),
N_("Pre-capture frames"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0301, "0x0301", "0x0301",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0302, "OneTouchWB", N_("One Touch WB"),
N_("One touch white balance"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOneTouchWb)),
TagInfo(0x0303, "0x0303", "0x0303",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0304, "0x0304", "0x0304",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0404, "SerialNumber", N_("Serial Number"),
N_("Serial number"),
olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x0e00, "PrintIM", N_("Print IM"),
N_("PrintIM information"),
olympusIfdId, makerTags, undefined, printValue),
TagInfo(0x0f00, "DataDump1", N_("Data Dump 1"),
N_("Various camera settings 1"),
olympusIfdId, makerTags, undefined, printValue),
TagInfo(0x0f01, "DataDump2", N_("Data Dump 2"),
N_("Various camera settings 2"),
olympusIfdId, makerTags, undefined, printValue),
TagInfo(0x1000, "ShutterSpeed", N_("Shutter Speed"),
N_("Shutter speed value"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1001, "ISOSpeed", N_("ISO Speed"),
N_("ISO speed value"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1002, "ApertureValue", N_("Aperture Value"),
N_("Aperture value"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1003, "Brightness", N_("Brightness"),
N_("Brightness value"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1004, "FlashMode", N_("Flash Mode"),
N_("Flash mode"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
TagInfo(0x1005, "FlashDevice", N_("Flash Device"),
N_("Flash device"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusFlashDevice)),
TagInfo(0x1006, "Bracket", N_("Bracket"),
N_("Exposure compensation value"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1007, "SensorTemperature", N_("Sensor Temperature"),
N_("Sensor temperature"),
olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x1008, "LensTemperature", N_("Lens Temperature"),
N_("Lens temperature"),
olympusIfdId, makerTags, signedShort, printValue),
TagInfo(0x1009, "0x1009", "0x1009",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100a, "0x100a", "0x100a",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100b, "FocusMode", N_("Focus Mode"),
N_("Focus mode"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusFocusMode)),
TagInfo(0x100c, "FocusDistance", N_("Focus Distance"),
N_("Manual focus distance"),
olympusIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x100d, "Zoom", N_("Zoom"),
N_("Zoom step count"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100e, "MacroFocus", N_("Macro Focus"),
N_("Macro focus step count"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x100f, "SharpnessFactor", N_("Sharpness Factor"),
N_("Sharpness factor"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusSharpness)),
TagInfo(0x1010, "FlashChargeLevel", N_("Flash Charge Level"),
N_("Flash charge level"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1011, "ColorMatrix", N_("Color Matrix"),
N_("Color matrix"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1012, "BlackLevel", N_("BlackLevel"),
N_("Black level"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1013, "0x1013", "0x1013",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1014, "0x1014", "0x1014",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1015, "WhiteBalance", N_("White Balance"),
N_("White balance mode"),
olympusIfdId, makerTags, unsignedShort, print0x1015),
TagInfo(0x1016, "0x1016", "0x1016",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1017, "RedBalance", N_("Red Balance"),
N_("Red balance"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1018, "BlueBalance", N_("Blue Balance"),
N_("Blue balance"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1019, "0x1019", "0x1019",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x101a, "SerialNumber2", N_("Serial Number 2"),
N_("Serial number 2"),
olympusIfdId, makerTags, asciiString, printValue),
TagInfo(0x101b, "0x101b", "0x101b",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101c, "0x101c", "0x101c",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101d, "0x101d", "0x101d",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101e, "0x101e", "0x101e",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x101f, "0x101f", "0x101f",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1020, "0x1020", "0x1020",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1021, "0x1021", "0x1021",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1022, "0x1022", "0x1022",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1023, "FlashBias", N_("Flash Bias"),
N_("Flash exposure compensation"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1024, "0x1024", "0x1024",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1025, "0x1025", "0x1025",
N_("Unknown"),
olympusIfdId, makerTags, signedRational, printValue),
TagInfo(0x1026, "ExternalFlashBounce", N_("External Flash Bounce"),
N_("External flash bounce"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
TagInfo(0x1027, "ExternalFlashZoom", N_("External Flash Zoom"),
N_("External flash zoom"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1028, "ExternalFlashMode", N_("External Flash Mode"),
N_("External flash mode"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1029, "Contrast", N_("Contrast"),
N_("Contrast setting"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusContrast)),
TagInfo(0x102a, "SharpnessFactor", N_("Sharpness Factor"),
N_("Sharpness factor"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102b, "ColorControl", N_("Color Control"),
N_("Color control"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102c, "ValidBits", N_("ValidBits"),
N_("Valid bits"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102d, "CoringFilter", N_("CoringFilter"),
N_("Coring filter"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x102e, "ImageWidth", N_("Image Width"),
N_("Image width"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x102f, "ImageHeight", N_("Image Height"),
N_("Image height"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1030, "0x1030", "0x1030",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1031, "0x1031", "0x1031",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1032, "0x1032", "0x1032",
N_("Unknown"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x1033, "0x1033", "0x1033",
N_("Unknown"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1034, "CompressionRatio", N_("Compression Ratio"),
N_("Compression ratio"),
olympusIfdId, makerTags, unsignedRational, printValue),
TagInfo(0x1035, "Thumbnail", N_("Thumbnail"),
N_("Preview image embedded"),
olympusIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(olympusOffOn)),
TagInfo(0x1036, "ThumbnailOffset", N_("Thumbnail Offset"),
N_("Offset of the preview image"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1037, "ThumbnailLength", N_("Thumbnail Length"),
N_("Size of the preview image"),
olympusIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x1039, "CCDScanMode", N_("CCD Scan Mode"),
N_("CCD scan mode"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusCCDScanMode)),
TagInfo(0x103a, "NoiseReduction", N_("Noise Reduction"),
N_("Noise reduction"),
olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
TagInfo(0x103b, "InfinityLensStep", N_("Infinity Lens Step"),
N_("Infinity lens step"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x103c, "NearLensStep", N_("Near Lens Step"),
N_("Near lens step"),
olympusIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x2010, "Equipment", N_("Equipment Info"),
N_("Camera equipment information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x2020, "CameraSettings", N_("Camera Settings"),
N_("Camera Settings information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x2030, "RawDevelopment", N_("Raw Development"),
N_("Raw development information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x2040, "ImageProcessing", N_("Image Processing"),
N_("Image processing information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x2050, "FocusInfo", N_("Focus Info"),
N_("Focus information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x3000, "RawInfo", N_("Raw Info"),
N_("Raw information"),
minoltaIfdId, makerTags, undefined, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownOlympusMakerNoteTag)", "(UnknownOlympusMakerNoteTag)",
N_("Unknown OlympusMakerNote tag"),
olympusIfdId, makerTags, invalidTypeId, printValue)
};
const TagInfo* OlympusMakerNote::tagList()
{
return tagInfo_;
}
//! @cond IGNORE
OlympusMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("OLYMPUS*", "*", createOlympusMakerNote);
MakerNoteFactory::registerMakerNote(olympusIfdId, MakerNote::AutoPtr(new OlympusMakerNote));
ExifTags::registerMakerTagInfo(olympusIfdId, tagInfo_);
}
//! @endcond
OlympusMakerNote::OlympusMakerNote(bool alloc)
: IfdMakerNote(olympusIfdId, alloc)
{
byte buf[] = {
'O', 'L', 'Y', 'M', 'P', 0x00, 0x01, 0x00
};
readHeader(buf, 8, byteOrder_);
}
OlympusMakerNote::OlympusMakerNote(const OlympusMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int OlympusMakerNote::readHeader(const byte* buf, long len, ByteOrder /*byteOrder*/)
{
if (len < 8) return 1;
// Copy the header
header_.alloc(8);
std::memcpy(header_.pData_, buf, header_.size_);
// Adjust the offset of the IFD for the prefix
start_ = 8;
return 0;
}
int OlympusMakerNote::checkHeader() const
{
int rc = 0;
// Check the OLYMPUS prefix
if ( header_.size_ < 8
|| std::string(reinterpret_cast<char*>(header_.pData_), 5)
!= std::string("OLYMP", 5)) {
rc = 2;
}
return rc;
}
OlympusMakerNote::AutoPtr OlympusMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
OlympusMakerNote* OlympusMakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new OlympusMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
OlympusMakerNote::AutoPtr OlympusMakerNote::clone() const
{
return AutoPtr(clone_());
}
OlympusMakerNote* OlympusMakerNote::clone_() const
{
return new OlympusMakerNote(*this);
}
std::ostream& OlympusMakerNote::print0x0200(std::ostream& os, const Value& value)
{
if (value.count() != 3 || value.typeId() != unsignedLong) {
return os << value;
}
long l0 = value.toLong(0);
switch (l0) {
case 0: os << _("Normal"); break;
case 2: os << _("Fast"); break;
case 3: os << _("Panorama"); break;
default: os << "(" << l0 << ")"; break;
}
if (l0 != 0) {
os << ", ";
long l1 = value.toLong(1);
os << _("Sequence number") << " " << l1;
}
if (l0 != 0 && l0 != 2) {
os << ", ";
long l2 = value.toLong(2);
switch (l2) {
case 1: os << _("Left to right"); break;
case 2: os << _("Right to left"); break;
case 3: os << _("Bottom to top"); break;
case 4: os << _("Top to bottom"); break;
default: os << "(" << l2 << ")"; break;
}
}
return os;
} // OlympusMakerNote::print0x0200
std::ostream& OlympusMakerNote::print0x0204(std::ostream& os, const Value& value)
{
float f = value.toFloat();
if (f == 0.0 || f == 1.0) return os << _("None");
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1) << f << "x";
os.copyfmt(oss);
return os;
} // OlympusMakerNote::print0x0204
std::ostream& OlympusMakerNote::print0x1015(std::ostream& os, const Value& value)
{
if (value.count() != 2 || value.typeId() != unsignedShort) {
return os << value;
}
short l0 = (short)value.toLong(0);
if (l0 != 1) {
os << _("Auto");
}
else {
short l1 = (short)value.toLong(1);
if (l1 != 1) {
switch (l0) {
case 0: os << _("Auto"); break;
default: os << _("Auto") << " (" << l0 << ")"; break;
}
}
else if (l1 != 2) {
switch (l0) {
case 2: os << _("3000 Kelvin"); break;
case 3: os << _("3700 Kelvin"); break;
case 4: os << _("4000 Kelvin"); break;
case 5: os << _("4500 Kelvin"); break;
case 6: os << _("5500 Kelvin"); break;
case 7: os << _("6500 Kelvin"); break;
case 8: os << _("7500 Kelvin"); break;
default: os << value; break;
}
}
else if (l1 != 3) {
switch (l0) {
case 0: os << _("One-touch"); break;
default: os << value; break;
}
}
else {
return os << value;
}
}
return os;
} // OlympusMakerNote::print0x1015
// *****************************************************************************
// free functions
MakerNote::AutoPtr createOlympusMakerNote(bool alloc, const byte* /*buf*/, long /*len*/,
ByteOrder /*byteOrder*/, long /*offset*/)
{
return MakerNote::AutoPtr(new OlympusMakerNote(alloc));
}
} // namespace Exiv2
namespace Exiv2 {
//! @cond IGNORE
SonyMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("SONY", "*", createSonyMakerNote);
MakerNoteFactory::registerMakerNote(
sonyIfdId, MakerNote::AutoPtr(new SonyMakerNote));
ExifTags::registerMakerTagInfo(sonyIfdId, tagInfo_);
}
//! @endcond
// Sony MakerNote Tag Info
const TagInfo SonyMakerNote::tagInfo_[] = {
TagInfo(0x2000, "0x2000", "0x2000",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9001, "0x9001", "0x9001",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9002, "0x9002", "0x9002",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9003, "0x9003", "0x9003",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9004, "0x9004", "0x9004",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9005, "0x9005", "0x9005",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9006, "0x9006", "0x9006",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9007, "0x9007", "0x9007",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
TagInfo(0x9008, "0x9008", "0x9008",
N_("Unknown"),
sonyIfdId, makerTags, undefined, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownSonyMakerNoteTag)", "(UnknownSonyMakerNoteTag)",
N_("Unknown SonyMakerNote tag"),
sonyIfdId, makerTags, invalidTypeId, printValue)
};
const TagInfo* SonyMakerNote::tagList()
{
return tagInfo_;
}
SonyMakerNote::SonyMakerNote(bool alloc)
: IfdMakerNote(sonyIfdId, alloc, false)
{
byte buf[] = {
'S', 'O', 'N', 'Y', ' ', 'D', 'S', 'C', ' ', '\0', '\0', '\0'
};
readHeader(buf, 12, byteOrder_);
}
SonyMakerNote::SonyMakerNote(const SonyMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int SonyMakerNote::readHeader(const byte* buf,
long len,
ByteOrder /*byteOrder*/)
{
if (len < 12) return 1;
header_.alloc(12);
std::memcpy(header_.pData_, buf, header_.size_);
// Adjust the offset of the IFD for the prefix
start_ = 12;
return 0;
}
int SonyMakerNote::checkHeader() const
{
int rc = 0;
// Check the SONY prefix
if ( header_.size_ < 12
|| std::string(reinterpret_cast<char*>(header_.pData_), 12)
!= std::string("SONY DSC \0\0\0", 12)) {
rc = 2;
}
return rc;
}
SonyMakerNote::AutoPtr SonyMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
SonyMakerNote* SonyMakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new SonyMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
SonyMakerNote::AutoPtr SonyMakerNote::clone() const
{
return AutoPtr(clone_());
}
SonyMakerNote* SonyMakerNote::clone_() const
{
return new SonyMakerNote(*this);
}
// *****************************************************************************
// free functions
MakerNote::AutoPtr createSonyMakerNote(bool alloc,
const byte* /*buf*/,
long /*len*/,
ByteOrder /*byteOrder*/,
long /*offset*/)
{
return MakerNote::AutoPtr(new SonyMakerNote(alloc));
}
} // namespace Exiv2
namespace Exiv2 {
//! @cond IGNORE
SigmaMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("SIGMA", "*", createSigmaMakerNote);
MakerNoteFactory::registerMakerNote("FOVEON", "*", createSigmaMakerNote);
MakerNoteFactory::registerMakerNote(
sigmaIfdId, MakerNote::AutoPtr(new SigmaMakerNote));
ExifTags::registerMakerTagInfo(sigmaIfdId, tagInfo_);
}
//! @endcond
// Sigma (Foveon) MakerNote Tag Info
const TagInfo SigmaMakerNote::tagInfo_[] = {
TagInfo(0x0002, "SerialNumber", "Camera serial number", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0003, "DriveMode", "Drive Mode", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0004, "ResolutionMode", "Resolution Mode", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0005, "AutofocusMode", "Autofocus mode", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0006, "FocusSetting", "Focus setting", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0007, "WhiteBalance", "White balance", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0008, "ExposureMode", "Exposure mode", sigmaIfdId, makerTags, asciiString, print0x0008),
TagInfo(0x0009, "MeteringMode", "Metering mode", sigmaIfdId, makerTags, asciiString, print0x0009),
TagInfo(0x000a, "LensRange", "Lens focal length range", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x000b, "ColorSpace", "Color space", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x000c, "Exposure", "Exposure", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x000d, "Contrast", "Contrast", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x000e, "Shadow", "Shadow", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x000f, "Highlight", "Highlight", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0010, "Saturation", "Saturation", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0011, "Sharpness", "Sharpness", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0012, "FillLight", "X3 Fill light", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0014, "ColorAdjustment", "Color adjustment", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0015, "AdjustmentMode", "Adjustment mode", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0016, "Quality", "Quality", sigmaIfdId, makerTags, asciiString, printStripLabel),
TagInfo(0x0017, "Firmware", "Firmware", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0018, "Software", "Software", sigmaIfdId, makerTags, asciiString, printValue),
TagInfo(0x0019, "AutoBracket", "Auto bracket", sigmaIfdId, makerTags, asciiString, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownSigmaMakerNoteTag)", "Unknown SigmaMakerNote tag", sigmaIfdId, makerTags, invalidTypeId, printValue)
};
SigmaMakerNote::SigmaMakerNote(bool alloc)
: IfdMakerNote(sigmaIfdId, alloc)
{
byte buf[] = {
'S', 'I', 'G', 'M', 'A', '\0', '\0', '\0', 0x01, 0x00
};
readHeader(buf, 10, byteOrder_);
}
SigmaMakerNote::SigmaMakerNote(const SigmaMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int SigmaMakerNote::readHeader(const byte* buf,
long len,
ByteOrder byteOrder)
{
if (len < 10) return 1;
// Copy the header. My one and only Sigma sample has two undocumented
// extra bytes (0x01, 0x00) between the ID string and the start of the
// Makernote IFD. So we copy 10 bytes into the header.
header_.alloc(10);
memcpy(header_.pData_, buf, header_.size_);
// Adjust the offset of the IFD for the prefix
adjOffset_ = 10;
return 0;
}
int SigmaMakerNote::checkHeader() const
{
int rc = 0;
// Check the SIGMA or FOVEON prefix
if ( header_.size_ < 10
|| std::string(reinterpret_cast<char*>(header_.pData_), 8)
!= std::string("SIGMA\0\0\0", 8)
&& std::string(reinterpret_cast<char*>(header_.pData_), 8)
!= std::string("FOVEON\0\0", 8)) {
rc = 2;
}
return rc;
}
SigmaMakerNote::AutoPtr SigmaMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
SigmaMakerNote* SigmaMakerNote::create_(bool alloc) const
{
AutoPtr makerNote = AutoPtr(new SigmaMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
SigmaMakerNote::AutoPtr SigmaMakerNote::clone() const
{
return AutoPtr(clone_());
}
SigmaMakerNote* SigmaMakerNote::clone_() const
{
return new SigmaMakerNote(*this);
}
std::ostream& SigmaMakerNote::printStripLabel(std::ostream& os,
const Value& value)
{
std::string v = value.toString();
std::string::size_type pos = v.find(':');
if (pos != std::string::npos) {
if (v[pos + 1] == ' ') ++pos;
v = v.substr(pos + 1);
}
return os << v;
}
std::ostream& SigmaMakerNote::print0x0008(std::ostream& os,
const Value& value)
{
switch (value.toString()[0]) {
case 'P': os << "Program"; break;
case 'A': os << "Aperture priority"; break;
case 'S': os << "Shutter priority"; break;
case 'M': os << "Manual"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& SigmaMakerNote::print0x0009(std::ostream& os,
const Value& value)
{
switch (value.toString()[0]) {
case 'A': os << "Average"; break;
case 'C': os << "Center"; break;
case '8': os << "8-Segment"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
// *****************************************************************************
// free functions
MakerNote::AutoPtr createSigmaMakerNote(bool alloc,
const byte* buf,
long len,
ByteOrder byteOrder,
long offset)
{
return MakerNote::AutoPtr(new SigmaMakerNote(alloc));
}
} // namespace Exiv2
namespace Internal {
//! Quality, tag 0x0001
extern const TagDetails panasonicQuality[] = {
{ 2, N_("High") },
{ 3, N_("Normal") },
{ 6, N_("Very High") },
{ 7, N_("Raw") },
{ 9, N_("Motion Picture") }
};
//! WhiteBalance, tag 0x0003
extern const TagDetails panasonicWhiteBalance[] = {
{ 1, N_("Auto") },
{ 2, N_("Daylight") },
{ 3, N_("Cloudy") },
{ 4, N_("Halogen") },
{ 5, N_("Manual") },
{ 8, N_("Flash") },
{ 10, N_("Black and white") },
{ 11, N_("Manual") },
{ 11, N_("Manual") } // To silence compiler warning
};
//! FocusMode, tag 0x0007
extern const TagDetails panasonicFocusMode[] = {
{ 1, N_("Auto") },
{ 2, N_("Manual") },
{ 4, N_("Auto, focus button") },
{ 5, N_("Auto, continuous") },
{ 5, N_("Auto, continuous") } // To silence compiler warning
};
//! ImageStabilizer, tag 0x001a
extern const TagDetails panasonicImageStabilizer[] = {
{ 2, N_("On, Mode 1") },
{ 3, N_("Off") },
{ 4, N_("On, Mode 2") }
};
//! Macro, tag 0x001c
extern const TagDetails panasonicMacro[] = {
{ 1, N_("On") },
{ 2, N_("Off") },
{ 257, N_("Tele-macro") }
};
//! ShootingMode, tag 0x001f and SceneMode, tag 0x8001
extern const TagDetails panasonicShootingMode[] = {
{ 0, N_("Off") }, // only SceneMode
{ 1, N_("Normal") },
{ 2, N_("Portrait") },
{ 3, N_("Scenery") },
{ 4, N_("Sports") },
{ 5, N_("Night portrait") },
{ 6, N_("Program") },
{ 7, N_("Aperture priority") },
{ 8, N_("Shutter-speed priority") },
{ 9, N_("Macro") },
{ 10, N_("Spot") },
{ 11, N_("Manual") },
{ 12, N_("Movie preview") },
{ 13, N_("Panning") },
{ 14, N_("Simple") },
{ 15, N_("Color effects") },
{ 18, N_("Fireworks") },
{ 19, N_("Party") },
{ 20, N_("Snow") },
{ 21, N_("Night scenery") },
{ 22, N_("Food") },
{ 23, N_("Baby") },
{ 24, N_("Soft skin") },
{ 25, N_("Candlelight") },
{ 26, N_("Starry night") },
{ 27, N_("High sensitivity") },
{ 28, N_("Panorama assist") },
{ 29, N_("Underwater") },
{ 30, N_("Beach") },
{ 31, N_("Aerial photo") },
{ 32, N_("Sunset") },
{ 33, N_("Pet") },
{ 34, N_("Intelligent ISO") },
{ 36, N_("High speed continuous shooting") },
{ 37, N_("Intelligent auto") },
};
//! Audio, tag 0x0020
extern const TagDetails panasonicAudio[] = {
{ 1, N_("Yes") },
{ 2, N_("No") }
};
//! ColorEffect, tag 0x0028
extern const TagDetails panasonicColorEffect[] = {
{ 1, N_("Off") },
{ 2, N_("Warm") },
{ 3, N_("Cool") },
{ 4, N_("Black and white") },
{ 5, N_("Sepia") }
};
//! BustMode, tag 0x002a
extern const TagDetails panasonicBurstMode[] = {
{ 0, N_("Off") },
{ 1, N_("Low/High quality") },
{ 2, N_("Infinite") }
};
//! Contrast, tag 0x002c
extern const TagDetails panasonicContrast[] = {
{ 0, N_("Normal") },
{ 1, N_("Low") },
{ 2, N_("High") },
{ 6, N_("Medium low") },
{ 7, N_("Medium high") },
{ 256, N_("Low") },
{ 272, N_("Standard") },
{ 288, N_("High") },
{ 288, N_("High") } // To silence compiler warning
};
//! NoiseReduction, tag 0x002d
extern const TagDetails panasonicNoiseReduction[] = {
{ 0, N_("Standard") },
{ 1, N_("Low (-1)") },
{ 2, N_("High (+1)") },
{ 3, N_("Lowest (-2)") },
{ 4, N_("Highest (+2)") }
};
//! SelfTimer, tag 0x002e
extern const TagDetails panasonicSelfTimer[] = {
{ 1, N_("Off") },
{ 2, N_("10s") },
{ 3, N_("2s") }
};
//! Rotation, tag 0x0030
extern const TagDetails panasonicRotation[] = {
{ 1, N_("Horizontal (normal)") },
{ 6, N_("Rotate 90 CW") },
{ 8, N_("Rotate 270 CW") }
};
//! ColorMode, tag 0x0032
extern const TagDetails panasonicColorMode[] = {
{ 0, N_("Normal") },
{ 1, N_("Natural") },
{ 2, N_("Vivid") }
};
//! OpticalZoomMode, tag 0x0034
extern const TagDetails panasonicOpticalZoomMode[] = {
{ 1, N_("Standard") },
{ 2, N_("EX optics") }
};
//! ConversionLens, tag 0x0035
extern const TagDetails panasonicConversionLens[] = {
{ 1, N_("Off") },
{ 2, N_("Wide") },
{ 3, N_("Telephoto") },
{ 4, N_("Macro") },
{ 4, N_("Macro") } // To silence compiler warning
};
//! WorldTimeLocation, tag 0x003a
extern const TagDetails panasonicWorldTimeLocation[] = {
{ 1, N_("Home") },
{ 2, N_("Destination") }
};
//! FilmMode, tag 0x0042
extern const TagDetails panasonicFilmMode[] = {
{ 1, N_("Standard (color)") },
{ 2, N_("Dynamic (color)") },
{ 3, N_("Nature (color)") },
{ 4, N_("Smooth (color)") },
{ 5, N_("Standard (B&W)") },
{ 6, N_("Dynamic (B&W)") },
{ 7, N_("Smooth (B&W)") }
};
// Panasonic MakerNote Tag Info
const TagInfo PanasonicMakerNote::tagInfo_[] = {
TagInfo(0x0001, "Quality", N_("Quality"), N_("Image Quality"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicQuality)),
TagInfo(0x0002, "FirmwareVersion", N_("Firmware Version"), N_("Firmware version"), panasonicId, makerTags, undefined, -1, printValue),
TagInfo(0x0003, "WhiteBalance", N_("White Balance"), N_("White balance setting"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicWhiteBalance)),
TagInfo(0x0004, "0x0004", "0x0004", N_("Unknown"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0007, "FocusMode", N_("Focus Mode"), N_("Focus mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicFocusMode)),
TagInfo(0x000f, "AFMode", N_("AF Mode"), N_("AF mode"), panasonicId, makerTags, unsignedByte, -1, print0x000f),
TagInfo(0x001a, "ImageStabilization", N_("Image Stabilization"), N_("Image stabilization"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicImageStabilizer)),
TagInfo(0x001c, "Macro", N_("Macro"), N_("Macro mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicMacro)),
TagInfo(0x001f, "ShootingMode", N_("Shooting Mode"), N_("Shooting mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicShootingMode)),
TagInfo(0x0020, "Audio", N_("Audio"), N_("Audio"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicAudio)),
TagInfo(0x0021, "DataDump", N_("Data Dump"), N_("Data dump"), panasonicId, makerTags, undefined, -1, printValue),
TagInfo(0x0022, "0x0022", "0x0022", N_("Unknown"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0023, "WhiteBalanceBias", N_("White Balance Bias"), N_("White balance adjustment"), panasonicId, makerTags, signedShort, -1, print0x0023),
TagInfo(0x0024, "FlashBias", N_("FlashBias"), N_("Flash bias"), panasonicId, makerTags, signedShort, -1, printValue),
TagInfo(0x0025, "InternalSerialNumber", N_("Internal Serial Number"), N_("This number is unique, and contains the date of manufacture, but is not the same as the number printed on the camera body."), panasonicId, makerTags, undefined, -1, printValue),
TagInfo(0x0026, "ExifVersion", "Exif Version", N_("Exif version"), panasonicId, makerTags, undefined, -1, printExifVersion),
TagInfo(0x0027, "0x0027", "0x0027", N_("Unknown"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0028, "ColorEffect", N_("Color Effect"), N_("Color effect"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicColorEffect)),
TagInfo(0x0029, "TimeSincePowerOn", "Time since Power On", N_("Time in 1/100 s from when the camera was powered on to when the image is written to memory card"), panasonicId, makerTags, unsignedLong, -1, printValue),
TagInfo(0x002a, "BurstMode", N_("Burst Mode"), N_("Burst mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicBurstMode)),
TagInfo(0x002b, "SequenceNumber", N_("Sequence Number"), N_("Sequence number"), panasonicId, makerTags, unsignedLong, -1, printValue),
TagInfo(0x002c, "Contrast", N_("Contrast"), N_("Contrast setting"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicContrast)),
TagInfo(0x002d, "NoiseReduction", N_("NoiseReduction"), N_("Noise reduction"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicNoiseReduction)),
TagInfo(0x002e, "SelfTimer", N_("Self Timer"), N_("Self timer"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicSelfTimer)),
TagInfo(0x002f, "0x002f", "0x002f", N_("Unknown"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0030, "Rotation", N_("Rotation"), N_("Rotation"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicRotation)),
TagInfo(0x0031, "0x0031", "0x0031", N_("Unknown"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0032, "ColorMode", N_("Color Mode"), N_("Color mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicColorMode)),
TagInfo(0x0033, "BabyAge", N_("Baby Age"), N_("Baby (or pet) age"), panasonicId, makerTags, asciiString, -1, printValue),
TagInfo(0x0034, "OpticalZoomMode", N_("Optical Zoom Mode"), N_("Optical zoom mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicOpticalZoomMode)),
TagInfo(0x0035, "ConversionLens", N_("Conversion Lens"), N_("Conversion lens"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicConversionLens)),
TagInfo(0x0036, "TravelDay", N_("Travel Day"), N_("Travel day"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0039, "Contrast", N_("Contrast"), N_("Contrast"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x003a, "WorldTimeLocation", N_("World Time Location"), N_("World time location"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicWorldTimeLocation)),
TagInfo(0x003c, "ProgramISO", N_("Program ISO"), N_("Program ISO"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0040, "Saturation", N_("Saturation"), N_("Saturation"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0041, "Sharpness", N_("Sharpness"), N_("Sharpness"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0042, "FilmMode", N_("Film Mode"), N_("Film mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicFilmMode)),
TagInfo(0x0046, "WBAdjustAB", N_("WB Adjust AB"), N_("WB adjust AB. Positive is a shift toward blue."), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0047, "WBAdjustGM", N_("WB Adjust GM"), N_("WBAdjustGM. Positive is a shift toward green."), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x0051, "LensType", N_("Lens Type"), N_("Lens type"), panasonicId, makerTags, asciiString, -1, printValue),
TagInfo(0x0052, "LensSerialNumber", N_("Lens Serial Number"), N_("Lens serial number"), panasonicId, makerTags, asciiString, -1, printValue),
TagInfo(0x0053, "AccessoryType", N_("Accessory Type"), N_("Accessory type"), panasonicId, makerTags, asciiString, -1, printValue),
TagInfo(0x0e00, "PrintIM", N_("Print IM"), N_("PrintIM information"), panasonicId, makerTags, undefined, -1, printValue),
TagInfo(0x4449, "0x4449", "0x4449", N_("Unknown"), panasonicId, makerTags, undefined, -1, printValue),
TagInfo(0x8000, "MakerNoteVersion", N_("MakerNote Version"), N_("MakerNote version"), panasonicId, makerTags, undefined, -1, printExifVersion),
TagInfo(0x8001, "SceneMode", N_("Scene Mode"), N_("Scene mode"), panasonicId, makerTags, unsignedShort, -1, EXV_PRINT_TAG(panasonicShootingMode)),
TagInfo(0x8004, "WBRedLevel", N_("WB Red Level"), N_("WB red level"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x8005, "WBGreenLevel", N_("WB Green Level"), N_("WB green level"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x8006, "WBBlueLevel", N_("WB Blue Level"), N_("WB blue level"), panasonicId, makerTags, unsignedShort, -1, printValue),
TagInfo(0x8010, "BabyAge", N_("Baby Age"), N_("Baby (or pet) age"), panasonicId, makerTags, asciiString, -1, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownPanasonicMakerNoteTag)", "(UnknownPanasonicMakerNoteTag)", N_("Unknown PanasonicMakerNote tag"), panasonicId, makerTags, asciiString, -1, printValue)
};
const TagInfo* PanasonicMakerNote::tagList()
{
return tagInfo_;
}
std::ostream& PanasonicMakerNote::print0x000f(std::ostream& os,
const Value& value,
const ExifData*)
{
if (value.count() < 2 || value.typeId() != unsignedByte) {
return os << value;
}
long l0 = value.toLong(0);
long l1 = value.toLong(1);
if (l0 == 0 && l1 == 1) os << _("Spot mode on");
else if (l0 == 0 && l1 == 16) os << _("Spot mode off or 3-area (high speed)");
else if (l0 == 1 && l1 == 0) os << _("Spot focussing");
else if (l0 == 1 && l1 == 1) os << _("5-area");
else if (l0 == 16 && l1 == 0) os << _("1-area");
else if (l0 == 16 && l1 == 16) os << _("1-area (high speed)");
else if (l0 == 32 && l1 == 0) os << _("3-area (auto)");
else if (l0 == 32 && l1 == 1) os << _("3-area (left)");
else if (l0 == 32 && l1 == 2) os << _("3-area (center)");
else if (l0 == 32 && l1 == 3) os << _("3-area (right)");
else os << value;
return os;
} // PanasonicMakerNote::print0x000f
std::ostream& PanasonicMakerNote::print0x0023(std::ostream& os,
const Value& value,
const ExifData*)
{
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1)
<< value.toLong() / 3 << _(" EV");
os.copyfmt(oss);
return os;
} // PanasonicMakerNote::print0x0023
// Panasonic MakerNote Tag Info
const TagInfo PanasonicMakerNote::tagInfoRaw_[] = {
TagInfo(0x0001, "Version", N_("Version"), N_("Panasonic raw version"), panaRawId, panaRaw, undefined, -1, printExifVersion),
TagInfo(0x0002, "SensorWidth", N_("Sensor Width"), N_("Sensor width"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0003, "SensorHeight", N_("Sensor Height"), N_("Sensor height"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0004, "SensorTopBorder", N_("Sensor Top Border"), N_("Sensor top border"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0005, "SensorLeftBorder", N_("Sensor Left Border"), N_("Sensor left border"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0006, "ImageHeight", N_("Image Height"), N_("Image height"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0007, "ImageWidth", N_("Image Width"), N_("Image width"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0011, "RedBalance", N_("Red Balance"), N_("Red balance (found in Digilux 2 RAW images)"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0012, "BlueBalance", N_("Blue Balance"), N_("Blue balance"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0017, "ISOSpeed", N_("ISO Speed"), N_("ISO speed setting"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0024, "WBRedLevel", N_("WB Red Level"), N_("WB red level"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0025, "WBGreenLevel", N_("WB Green Level"), N_("WB green level"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0026, "WBBlueLevel", N_("WB Blue Level"), N_("WB blue level"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x002e, "PreviewImage", N_("Preview Image"), N_("Preview image"), panaRawId, panaRaw, undefined, -1, printValue),
TagInfo(0x010f, "Make", N_("Manufacturer"), N_("The manufacturer of the recording equipment"), panaRawId, panaRaw, asciiString, -1, printValue),
TagInfo(0x0110, "Model", N_("Model"), N_("The model name or model number of the equipment"), panaRawId, panaRaw, asciiString, -1, printValue),
TagInfo(0x0111, "StripOffsets", N_("Strip Offsets"), N_("Strip offsets"), panaRawId, panaRaw, unsignedLong, -1, printValue),
TagInfo(0x0112, "Orientation", N_("Orientation"), N_("Orientation"), panaRawId, panaRaw, unsignedShort, -1, print0x0112),
TagInfo(0x0116, "RowsPerStrip", N_("Rows Per Strip"), N_("The number of rows per strip"), panaRawId, panaRaw, unsignedShort, -1, printValue),
TagInfo(0x0117, "StripByteCounts", N_("Strip Byte Counts"), N_("Strip byte counts"), panaRawId, panaRaw, unsignedLong, -1, printValue),
TagInfo(0x0118, "RawDataOffset", N_("Raw Data Offset"), N_("Raw data offset"), panaRawId, panaRaw, unsignedLong, -1, printValue),
TagInfo(0x8769, "ExifTag", N_("Exif IFD Pointer"), N_("A pointer to the Exif IFD"), panaRawId, panaRaw, unsignedLong, -1, printValue),
TagInfo(0x8825, "GPSTag", N_("GPS Info IFD Pointer"), N_("A pointer to the GPS Info IFD"), panaRawId, panaRaw, unsignedLong, -1, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownPanasonicRawTag)", "(UnknownPanasonicRawTag)", N_("Unknown PanasonicRaw tag"), panaRawId, panaRaw, asciiString, -1, printValue)
};
const TagInfo* PanasonicMakerNote::tagListRaw()
{
return tagInfoRaw_;
}
}} // namespace Internal, Exiv2
int TracksInfo( TRACKS* pTracks, char* pBuffer, int nSize )
{
int i, pos = 0, video_num=0, audio_num=0;
int h_264_present=0, video_data_present=0, audio_data_present=0;
char *p = pBuffer;
ES_ELEMENT *pESElmnt;
unsigned long bit_rate = 0;
if ( IS_TS_TYPE( pTracks->track_type ) )
{
if ( !(pTracks->track_attr & (ATTR_VIDEO_PRESENT|ATTR_AUDIO_PRESENT)) )
{
if ( ( pTracks->track_attr & ATTR_ENCRYPTED_FLAG ) )
{
pos += snprintf( pBuffer, nSize-pos, "ENCRYPTED-TS;" );
return pos;
}
pos += snprintf( pBuffer, nSize-pos, "NO-AV-TS;" );
return pos;
}
if ( pTracks->main_video_index != 0xffff )
pESElmnt = pTracks->track[pTracks->main_video_index].es_elmnt;
else
if ( pTracks->main_audio_index != 0xffff )
pESElmnt = pTracks->track[pTracks->main_audio_index].es_elmnt;
else
{
pos += snprintf( p+pos, nSize-pos, "Error: no main video and audio specified." );
return 0; //no main track found;
}
if ( pESElmnt->es_type == ES_MPEG1 )
pos += snprintf( pBuffer, nSize-pos, "MPEG1-TS;" );
else
if ( pESElmnt->es_type == ES_MPEG2 )
pos += snprintf( pBuffer, nSize-pos, "MPEG2-TS;" );
else
{
if ( ( pTracks->track_attr & ATTR_ENCRYPTED_FLAG ) )
pos += snprintf( pBuffer, nSize-pos, "ENCRYPTED-TS;" );
else
pos += snprintf( pBuffer, nSize-pos, "UNKNOWN-TS;" );
}
} else
{
if ( pTracks->main_video_index != 0xffff )
pESElmnt = pTracks->track[pTracks->main_video_index].es_elmnt;
else
if ( pTracks->main_audio_index != 0xffff )
pESElmnt = pTracks->track[pTracks->main_audio_index].es_elmnt;
else
{
pos += snprintf( p+pos, nSize-pos, "Error: no main video and audio specified." );
return 0; //no main track found;
}
if ( pESElmnt->es_type == ES_MPEG1 )
pos += snprintf( p, nSize-pos, "MPEG1-PS;" );
else
if ( pESElmnt->es_type == ES_MPEG2 )
pos += snprintf( p, nSize-pos, "MPEG2-PS;" );
else
pos += snprintf( p, nSize-pos, "UNKNOWN-PS;" );
}
for ( i = 0; i<pTracks->number_track; i++ )
{
if ( pTracks->track[i].ts_elmnt &&
pTracks->track[i].ts_elmnt->content_type == VIDEO_DATA &&
pTracks->track[i].ts_packets_counter > 2 )
{
video_data_present = 1;
if ( pTracks->track[i].ts_elmnt->format_fourcc == SAGE_FOURCC( "H264" ) )
h_264_present=1;
}
if ( pTracks->track[i].ts_elmnt &&
pTracks->track[i].ts_elmnt->content_type == AUDIO_DATA &&
pTracks->track[i].ts_packets_counter > 2 )
{
audio_data_present = 1;
}
if ( pTracks->track[i].av_elmnt->content_type == VIDEO_DATA )
{
bit_rate += GetVideoRate( pTracks->track[i].av_elmnt );
video_num++;
}
if ( pTracks->track[i].av_elmnt->content_type == AUDIO_DATA )
{
bit_rate += GetAudioRate( pTracks->track[i].av_elmnt );
audio_num++;
}
}
if ( nSize > pos && bit_rate > 0 )
pos += snprintf( p+pos, nSize-pos, "br=%ld;", bit_rate );
if ( IS_TS_TYPE( pTracks->track_type ) )
{
pos += snprintf( p+pos, nSize-pos, "%s",
pTracks->track_type==MPEG_M2TS?"ps=192;":pTracks->track_type==MPEG_ASI?"ps=208;":"" );
}
if ( video_num == 0 )
{
if ( IS_TS_TYPE( pTracks->track_type ) )
{
if ( !video_data_present && audio_num > 0) //R5000 recording live tv has enough data to parse out video AV info,
pos += snprintf( p+pos, nSize-pos, "audioonly=1;" );
} else
{
pos += snprintf( p+pos, nSize-pos, "audioonly=1;" );
}
}
if ( audio_num == 0 )
{
if ( IS_TS_TYPE( pTracks->track_type ) )
{
if ( !audio_data_present && video_num > 0 ) //R5000 recording live tv has enough data to parse out video AV info,
pos += snprintf( p+pos, nSize-pos, "videoonly=1;" );
} else
{
pos += snprintf( p+pos, nSize-pos, "videoonly=1;" );
}
}
for ( i = 0; i<pTracks->number_track ; i++ )
{
if ( pTracks->track[i].av_elmnt->content_type == VIDEO_DATA )
{
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "[" );
pos += AVElmntInfo( pTracks->track[i].av_elmnt, p+pos, nSize-pos );
if ( i == pTracks->main_video_index )
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "main=yes;" );
pos += TagInfo( pTracks->track_type, pTracks->track[i].ts_elmnt,
pTracks->track[i].es_elmnt, p+pos, nSize-pos );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "index=%d;", pTracks->track[i].av_elmnt->stream_index );
if ( nSize > pos+2 ) { p[pos++] = ']'; p[pos++] = ';'; } //terminator
}
}
for ( i = 0; i<pTracks->number_track ; i++ )
{
if ( pTracks->track[i].av_elmnt->content_type == AUDIO_DATA )
{
char tmp[16];
unsigned long language_code;
unsigned char audio_type;
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "[" );
pos += AVElmntInfo( pTracks->track[i].av_elmnt, p+pos, nSize-pos );
if ( i == pTracks->main_audio_index )
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "main=yes;" );
if ( pTracks->track[i].ts_elmnt != NULL && pTracks->track[i].ts_elmnt->language_code )
{
language_code = pTracks->track[i].ts_elmnt->language_code;
audio_type = pTracks->track[i].ts_elmnt->audio_type;
}
else
{
language_code = pTracks->track[i].es_elmnt->language_code;
audio_type = pTracks->track[i].es_elmnt->audio_type;
}
if ( language_code )
{
if ( language_code == LanguageCode( (unsigned char*)"qaa" ) )
strncpy( tmp, "original", sizeof(tmp) );
else
Language(language_code, tmp );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "lang=%s;", tmp );
}
if ( audio_type )
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "ty=%s;",AudioType(audio_type) );
pos += TagInfo( pTracks->track_type, pTracks->track[i].ts_elmnt,
pTracks->track[i].es_elmnt, p+pos, nSize-pos );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "index=%d;", pTracks->track[i].av_elmnt->stream_index );
if ( nSize > pos+3 ) { p[pos++] = ']'; p[pos++] = ';'; } //terminator
}
}
for ( i = 0; i<pTracks->number_track ; i++ )
{
if ( pTracks->track[i].av_elmnt->content_type == SUBTITLE_DATA )
{
char tmp[16];
unsigned long language_code;
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "[" );
pos += AVElmntInfo( pTracks->track[i].av_elmnt, p+pos, nSize-pos );
if ( pTracks->track[i].ts_elmnt != NULL && pTracks->track[i].ts_elmnt->language_code )
language_code = pTracks->track[i].ts_elmnt->language_code;
else
language_code = pTracks->track[i].es_elmnt->language_code;
if ( language_code )
{
Language(language_code, tmp );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "lang=%s;", tmp );
}
pos += TagInfo( pTracks->track_type, pTracks->track[i].ts_elmnt,
pTracks->track[i].es_elmnt, p+pos, nSize-pos );
if ( nSize > pos ) pos += snprintf( p+pos, nSize-pos, "index=%d;", pTracks->track[i].av_elmnt->stream_index );
if ( nSize > pos+2 ) { p[pos++] = ']'; p[pos++] = ';'; } //terminator
}
}
if ( pos < nSize ) p[pos]= 0x0;
return pos;
}
namespace Exiv2 {
//! @cond IGNORE
Nikon1MakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("NIKON*", "*", createNikonMakerNote);
MakerNoteFactory::registerMakerNote(
nikon1IfdId, MakerNote::AutoPtr(new Nikon1MakerNote));
ExifTags::registerMakerTagInfo(nikon1IfdId, tagInfo_);
}
//! @endcond
// Nikon1 MakerNote Tag Info
const TagInfo Nikon1MakerNote::tagInfo_[] = {
TagInfo(0x0001, "Version", "Version", "Nikon Makernote version", nikon1IfdId, makerTags, undefined, printValue),
TagInfo(0x0002, "ISOSpeed", "ISOSpeed", "ISO speed setting", nikon1IfdId, makerTags, unsignedShort, print0x0002),
TagInfo(0x0003, "ColorMode", "ColorMode", "Color mode", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0004, "Quality", "Quality", "Image quality setting", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0005, "WhiteBalance", "WhiteBalance", "White balance", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0006, "Sharpening", "Sharpening", "Image sharpening setting", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0007, "Focus", "Focus", "Focus mode", nikon1IfdId, makerTags, asciiString, print0x0007),
TagInfo(0x0008, "Flash", "Flash", "Flash mode", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x000a, "0x000a", "0x000a", "Unknown", nikon1IfdId, makerTags, unsignedRational, printValue),
TagInfo(0x000f, "ISOSelection", "ISOSelection", "ISO selection", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0010, "DataDump", "DataDump", "Data dump", nikon1IfdId, makerTags, undefined, printValue),
TagInfo(0x0080, "ImageAdjustment", "ImageAdjustment", "Image adjustment setting", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0082, "Adapter", "Adapter", "Adapter used", nikon1IfdId, makerTags, asciiString, printValue),
TagInfo(0x0085, "FocusDistance", "FocusDistance", "Manual focus distance", nikon1IfdId, makerTags, unsignedRational, print0x0085),
TagInfo(0x0086, "DigitalZoom", "DigitalZoom", "Digital zoom setting", nikon1IfdId, makerTags, unsignedRational, print0x0086),
TagInfo(0x0088, "AFFocusPos", "AFFocusPos", "AF focus position", nikon1IfdId, makerTags, undefined, print0x0088),
// End of list marker
TagInfo(0xffff, "(UnknownNikon1MnTag)", "(UnknownNikon1MnTag)", "Unknown Nikon1MakerNote tag", nikon1IfdId, makerTags, invalidTypeId, printValue)
};
Nikon1MakerNote::Nikon1MakerNote(bool alloc)
: IfdMakerNote(nikon1IfdId, alloc)
{
}
Nikon1MakerNote::Nikon1MakerNote(const Nikon1MakerNote& rhs)
: IfdMakerNote(rhs)
{
}
Nikon1MakerNote::AutoPtr Nikon1MakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
Nikon1MakerNote* Nikon1MakerNote::create_(bool alloc) const
{
return new Nikon1MakerNote(alloc);
}
Nikon1MakerNote::AutoPtr Nikon1MakerNote::clone() const
{
return AutoPtr(clone_());
}
Nikon1MakerNote* Nikon1MakerNote::clone_() const
{
return new Nikon1MakerNote(*this);
}
std::ostream& Nikon1MakerNote::print0x0002(std::ostream& os,
const Value& value)
{
if (value.count() > 1) {
os << value.toLong(1);
}
else {
os << "(" << value << ")";
}
return os;
}
std::ostream& Nikon1MakerNote::print0x0007(std::ostream& os,
const Value& value)
{
std::string focus = value.toString();
if (focus == "AF-C ") os << "Continuous autofocus";
else if (focus == "AF-S ") os << "Single autofocus";
else os << "(" << value << ")";
return os;
}
std::ostream& Nikon1MakerNote::print0x0085(std::ostream& os,
const Value& value)
{
Rational distance = value.toRational();
if (distance.first == 0) {
os << "Unknown";
}
else if (distance.second != 0) {
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(2)
<< (float)distance.first / distance.second
<< " m";
os.copyfmt(oss);
}
else {
os << "(" << value << ")";
}
return os;
}
std::ostream& Nikon1MakerNote::print0x0086(std::ostream& os,
const Value& value)
{
Rational zoom = value.toRational();
if (zoom.first == 0) {
os << "Not used";
}
else if (zoom.second != 0) {
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1)
<< (float)zoom.first / zoom.second
<< "x";
os.copyfmt(oss);
}
else {
os << "(" << value << ")";
}
return os;
}
std::ostream& Nikon1MakerNote::print0x0088(std::ostream& os,
const Value& value)
{
if (value.count() > 1) {
switch (value.toLong(1)) {
case 0: os << "Center"; break;
case 1: os << "Top"; break;
case 2: os << "Bottom"; break;
case 3: os << "Left"; break;
case 4: os << "Right"; break;
default: os << "(" << value << ")"; break;
}
}
else {
os << "(" << value << ")";
}
return os;
}
//! @cond IGNORE
Nikon2MakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote(
nikon2IfdId, MakerNote::AutoPtr(new Nikon2MakerNote));
ExifTags::registerMakerTagInfo(nikon2IfdId, tagInfo_);
}
//! @endcond
// Nikon2 MakerNote Tag Info
const TagInfo Nikon2MakerNote::tagInfo_[] = {
TagInfo(0x0002, "0x0002", "0x0002", "Unknown", nikon2IfdId, makerTags, asciiString, printValue),
TagInfo(0x0003, "Quality", "Quality", "Image quality setting", nikon2IfdId, makerTags, unsignedShort, print0x0003),
TagInfo(0x0004, "ColorMode", "ColorMode", "Color mode", nikon2IfdId, makerTags, unsignedShort, print0x0004),
TagInfo(0x0005, "ImageAdjustment", "ImageAdjustment", "Image adjustment setting", nikon2IfdId, makerTags, unsignedShort, print0x0005),
TagInfo(0x0006, "ISOSpeed", "ISOSpeed", "ISO speed setting", nikon2IfdId, makerTags, unsignedShort, print0x0006),
TagInfo(0x0007, "WhiteBalance", "WhiteBalance", "White balance", nikon2IfdId, makerTags, unsignedShort, print0x0007),
TagInfo(0x0008, "Focus", "Focus", "Focus mode", nikon2IfdId, makerTags, unsignedRational, printValue),
TagInfo(0x0009, "0x0009", "0x0009", "Unknown", nikon2IfdId, makerTags, asciiString, printValue),
TagInfo(0x000a, "DigitalZoom", "DigitalZoom", "Digital zoom setting", nikon2IfdId, makerTags, unsignedRational, print0x000a),
TagInfo(0x000b, "Adapter", "Adapter", "Adapter used", nikon2IfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0f00, "0x0f00", "0x0f00", "Unknown", nikon2IfdId, makerTags, unsignedLong, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownNikon2MnTag)", "(UnknownNikon2MnTag)", "Unknown Nikon2MakerNote tag", nikon2IfdId, makerTags, invalidTypeId, printValue)
};
Nikon2MakerNote::Nikon2MakerNote(bool alloc)
: IfdMakerNote(nikon2IfdId, alloc)
{
byte buf[] = {
'N', 'i', 'k', 'o', 'n', '\0', 0x00, 0x01
};
readHeader(buf, 8, byteOrder_);
}
Nikon2MakerNote::Nikon2MakerNote(const Nikon2MakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int Nikon2MakerNote::readHeader(const byte* buf,
long len,
ByteOrder byteOrder)
{
if (len < 8) return 1;
header_.alloc(8);
memcpy(header_.pData_, buf, header_.size_);
start_ = 8;
return 0;
}
int Nikon2MakerNote::checkHeader() const
{
int rc = 0;
// Check the Nikon prefix
if ( header_.size_ < 8
|| std::string(reinterpret_cast<char*>(header_.pData_), 6)
!= std::string("Nikon\0", 6)) {
rc = 2;
}
return rc;
}
Nikon2MakerNote::AutoPtr Nikon2MakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
Nikon2MakerNote* Nikon2MakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new Nikon2MakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
Nikon2MakerNote::AutoPtr Nikon2MakerNote::clone() const
{
return AutoPtr(clone_());
}
Nikon2MakerNote* Nikon2MakerNote::clone_() const
{
return new Nikon2MakerNote(*this);
}
std::ostream& Nikon2MakerNote::print0x0003(std::ostream& os,
const Value& value)
{
long quality = value.toLong();
switch (quality) {
case 1: os << "VGA Basic"; break;
case 2: os << "VGA Normal"; break;
case 3: os << "VGA Fine"; break;
case 4: os << "SXGA Basic"; break;
case 5: os << "SXGA Normal"; break;
case 6: os << "SXGA Fine"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon2MakerNote::print0x0004(std::ostream& os,
const Value& value)
{
long color = value.toLong();
switch (color) {
case 1: os << "Color"; break;
case 2: os << "Monochrome"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon2MakerNote::print0x0005(std::ostream& os,
const Value& value)
{
long adjustment = value.toLong();
switch (adjustment) {
case 0: os << "Normal"; break;
case 1: os << "Bright+"; break;
case 2: os << "Bright-"; break;
case 3: os << "Contrast+"; break;
case 4: os << "Contrast-"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon2MakerNote::print0x0006(std::ostream& os,
const Value& value)
{
long iso = value.toLong();
switch (iso) {
case 0: os << "80"; break;
case 2: os << "160"; break;
case 4: os << "320"; break;
case 5: os << "100"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon2MakerNote::print0x0007(std::ostream& os,
const Value& value)
{
long wb = value.toLong();
switch (wb) {
case 0: os << "Auto"; break;
case 1: os << "Preset"; break;
case 2: os << "Daylight"; break;
case 3: os << "Incandescent"; break;
case 4: os << "Fluorescent"; break;
case 5: os << "Cloudy"; break;
case 6: os << "Speedlight"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon2MakerNote::print0x000a(std::ostream& os,
const Value& value)
{
Rational zoom = value.toRational();
if (zoom.first == 0) {
os << "Not used";
}
else if (zoom.second != 0) {
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1)
<< (float)zoom.first / zoom.second
<< "x";
os.copyfmt(oss);
}
else {
os << "(" << value << ")";
}
return os;
}
//! @cond IGNORE
Nikon3MakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote(
nikon3IfdId, MakerNote::AutoPtr(new Nikon3MakerNote));
ExifTags::registerMakerTagInfo(nikon3IfdId, tagInfo_);
}
//! @endcond
// Nikon3 MakerNote Tag Info
const TagInfo Nikon3MakerNote::tagInfo_[] = {
TagInfo(0x0001, "Version", "Version", "Nikon Makernote version", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x0002, "ISOSpeed", "ISOSpeed", "ISO speed used", nikon3IfdId, makerTags, unsignedShort, print0x0002),
TagInfo(0x0003, "ColorMode", "ColorMode", "Color mode", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0004, "Quality", "Quality", "Image quality setting", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0005, "WhiteBalance", "WhiteBalance", "White balance", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0006, "Sharpening", "Sharpening", "Image sharpening setting", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0007, "Focus", "Focus", "Focus mode", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0008, "FlashSetting", "FlashSetting", "Flash setting", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0009, "FlashMode", "FlashMode", "Flash mode", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x000b, "WhiteBalanceBias", "WhiteBalanceBias", "White balance bias", nikon3IfdId, makerTags, signedShort, printValue),
// TagInfo(0x000c, "ColorBalance1", "ColorBalance1", "Color balance 1", nikon3IfdId, makerTags, xxx, printValue),
TagInfo(0x000d, "0x000d", "0x000d", "Unknown", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x000e, "ExposureDiff", "ExposureDiff", "Exposure difference", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x000f, "ISOSelection", "ISOSelection", "ISO selection", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0010, "DataDump", "DataDump", "Data dump", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x0011, "ThumbOffset", "ThumbOffset", "Thumbnail IFD offset", nikon3IfdId, makerTags, unsignedLong, printValue),
TagInfo(0x0012, "FlashComp", "FlashComp", "Flash compensation setting", nikon3IfdId, makerTags, undefined, print0x0012),
TagInfo(0x0013, "ISOSetting", "ISOSetting", "ISO speed setting", nikon3IfdId, makerTags, unsignedShort, print0x0002), // use 0x0002 print fct
TagInfo(0x0016, "ImageBoundry", "ImageBoundry", "Image boundry", nikon3IfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0017, "0x0017", "0x0017", "Unknown", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x0018, "FlashBracketComp", "FlashBracketComp", "Flash bracket compensation applied", nikon3IfdId, makerTags, undefined, print0x0012), // use 0x0012 print fct
TagInfo(0x0019, "ExposureBracketComp", "ExposureBracketComp", "AE bracket compensation applied", nikon3IfdId, makerTags, signedRational, printValue),
TagInfo(0x0080, "ImageAdjustment", "ImageAdjustment", "Image adjustment setting", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0081, "ToneComp", "ToneComp", "Tone compensation setting (contrast)", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0082, "AuxiliaryLens", "AuxiliaryLens", "Auxiliary lens (adapter)", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0083, "LensType", "LensType", "Lens type", nikon3IfdId, makerTags, unsignedByte, printValue),
TagInfo(0x0084, "Lens", "Lens", "Lens", nikon3IfdId, makerTags, unsignedRational, print0x0084),
TagInfo(0x0085, "FocusDistance", "FocusDistance", "Manual focus distance", nikon3IfdId, makerTags, unsignedRational, printValue),
TagInfo(0x0086, "DigitalZoom", "DigitalZoom", "Digital zoom setting", nikon3IfdId, makerTags, unsignedRational, printValue),
TagInfo(0x0087, "FlashType", "FlashType", "Type of flash used", nikon3IfdId, makerTags, unsignedByte, print0x0087),
TagInfo(0x0088, "AFFocusPos", "AFFocusPos", "AF focus position", nikon3IfdId, makerTags, undefined, print0x0088),
TagInfo(0x0089, "Bracketing", "Bracketing", "Bracketing", nikon3IfdId, makerTags, unsignedShort, print0x0089),
TagInfo(0x008a, "0x008a", "0x008a", "Unknown", nikon3IfdId, makerTags, unsignedShort, printValue),
TagInfo(0x008b, "LensFStops", "LensFStops", "Number of lens stops", nikon3IfdId, makerTags, undefined, print0x008b),
// TagInfo(0x008c, "NEFCurve1", "NEFCurve1", "NEF curve 1", nikon3IfdId, makerTags, xxx, printValue),
TagInfo(0x008d, "ColorMode", "ColorMode", "Color mode", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x008f, "SceneMode", "SceneMode", "Scene mode", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0090, "LightingType", "LightingType", "Lighting type", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x0091, "0x0091", "0x0091", "Unknown", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x0092, "HueAdjustment", "HueAdjustment", "Hue adjustment", nikon3IfdId, makerTags, signedShort, printValue),
TagInfo(0x0094, "Saturation", "Saturation", "Saturation adjustment", nikon3IfdId, makerTags, signedShort, printValue),
TagInfo(0x0095, "NoiseReduction", "NoiseReduction", "Noise reduction", nikon3IfdId, makerTags, asciiString, printValue),
// TagInfo(0x0096, "NEFCurve2", "NEFCurve2", "NEF curve 2", nikon3IfdId, makerTags, xxx, printValue),
TagInfo(0x0097, "ColorBalance2", "ColorBalance2", "Color balance 2", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x0098, "LensData", "LensData", "Lens data", nikon3IfdId, makerTags, undefined, print0x0098),
TagInfo(0x0099, "NEFThumbnailSize", "NEFThumbnailSize", "NEF thumbnail size", nikon3IfdId, makerTags, unsignedShort, printValue),
TagInfo(0x009a, "0x009a", "0x009a", "Unknown", nikon3IfdId, makerTags, unsignedRational, printValue),
TagInfo(0x009b, "0x009b", "0x009b", "Unknown", nikon3IfdId, makerTags, unsignedShort, printValue),
TagInfo(0x009f, "0x009f", "0x009f", "Unknown", nikon3IfdId, makerTags, signedShort, printValue),
TagInfo(0x00a0, "SerialNumber", "SerialNumber", "Camera serial number", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x00a2, "0x00a2", "0x00a2", "Unknown", nikon3IfdId, makerTags, unsignedLong, printValue),
TagInfo(0x00a3, "0x00a3", "0x00a3", "Unknown", nikon3IfdId, makerTags, unsignedByte, printValue),
TagInfo(0x00a5, "0x00a5", "0x00a5", "Unknown", nikon3IfdId, makerTags, unsignedLong, printValue),
TagInfo(0x00a6, "0x00a6", "0x00a6", "Unknown", nikon3IfdId, makerTags, unsignedLong, printValue),
TagInfo(0x00a7, "ShutterCount", "ShutterCount", "Number of shots taken by camera", nikon3IfdId, makerTags, unsignedLong, printValue),
TagInfo(0x00a8, "0x00a8", "0x00a8", "Unknown", nikon3IfdId, makerTags, undefined, printValue),
TagInfo(0x00a9, "ImageOptimization", "ImageOptimization", "Image optimization", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x00aa, "Saturation", "Saturation", "Saturation", nikon3IfdId, makerTags, asciiString, printValue),
TagInfo(0x00ab, "VariProgram", "VariProgram", "Vari program", nikon3IfdId, makerTags, asciiString, printValue),
// TagInfo(0x0e00, "PrintIM", "PrintIM", "Print image matching", nikon3IfdId, makerTags, xxx, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownNikon3MnTag)", "(UnknownNikon3MnTag)", "Unknown Nikon3MakerNote tag", nikon3IfdId, makerTags, invalidTypeId, printValue)
};
Nikon3MakerNote::Nikon3MakerNote(bool alloc)
: IfdMakerNote(nikon3IfdId, alloc)
{
absShift_ = false;
byte buf[] = {
'N', 'i', 'k', 'o', 'n', '\0',
0x02, 0x10, 0x00, 0x00, 0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08
};
readHeader(buf, 18, byteOrder_);
}
Nikon3MakerNote::Nikon3MakerNote(const Nikon3MakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int Nikon3MakerNote::readHeader(const byte* buf,
long len,
ByteOrder byteOrder)
{
if (len < 18) return 1;
header_.alloc(18);
memcpy(header_.pData_, buf, header_.size_);
TiffHeader tiffHeader;
tiffHeader.read(header_.pData_ + 10);
byteOrder_ = tiffHeader.byteOrder();
start_ = 10 + tiffHeader.offset();
shift_ = 10;
return 0;
}
int Nikon3MakerNote::checkHeader() const
{
int rc = 0;
// Check the Nikon prefix
if ( header_.size_ < 18
|| std::string(reinterpret_cast<char*>(header_.pData_), 6)
!= std::string("Nikon\0", 6)) {
rc = 2;
}
return rc;
}
Nikon3MakerNote::AutoPtr Nikon3MakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
Nikon3MakerNote* Nikon3MakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new Nikon3MakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
Nikon3MakerNote::AutoPtr Nikon3MakerNote::clone() const
{
return AutoPtr(clone_());
}
Nikon3MakerNote* Nikon3MakerNote::clone_() const
{
return new Nikon3MakerNote(*this);
}
std::ostream& Nikon3MakerNote::print0x0002(std::ostream& os,
const Value& value)
{
if (value.count() > 1) {
os << value.toLong(1);
}
else {
os << "(" << value << ")";
}
return os;
}
std::ostream& Nikon3MakerNote::print0x0012(std::ostream& os,
const Value& value)
{
// From the PHP JPEG Metadata Toolkit
long fec = value.toLong();
switch (fec) {
case 0x06: os << "+1.0 EV"; break;
case 0x04: os << "+0.7 EV"; break;
case 0x03: os << "+0.5 EV"; break;
case 0x02: os << "+0.3 EV"; break;
case 0x00: os << "0.0 EV"; break;
case 0xfe: os << "-0.3 EV"; break;
case 0xfd: os << "-0.5 EV"; break;
case 0xfc: os << "-0.7 EV"; break;
case 0xfa: os << "-1.0 EV"; break;
case 0xf8: os << "-1.3 EV"; break;
case 0xf7: os << "-1.5 EV"; break;
case 0xf6: os << "-1.7 EV"; break;
case 0xf4: os << "-2.0 EV"; break;
case 0xf2: os << "-2.3 EV"; break;
case 0xf1: os << "-2.5 EV"; break;
case 0xf0: os << "-2.7 EV"; break;
case 0xee: os << "-3.0 EV"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon3MakerNote::print0x0084(std::ostream& os,
const Value& value)
{
if (value.count() == 4) {
long len1 = value.toLong(0);
long len2 = value.toLong(1);
Rational fno1 = value.toRational(2);
Rational fno2 = value.toRational(3);
os << len1;
if (len2 != len1) {
os << "-" << len2;
}
os << "mm ";
std::ostringstream oss;
oss.copyfmt(os);
os << "F" << std::setprecision(2)
<< static_cast<float>(fno1.first) / fno1.second;
if (fno2 != fno1) {
os << "-" << std::setprecision(2)
<< static_cast<float>(fno2.first) / fno2.second;
}
os.copyfmt(oss);
}
else {
os << "(" << value << ")";
}
return os;
}
std::ostream& Nikon3MakerNote::print0x0087(std::ostream& os,
const Value& value)
{
// From Exiftool
long flash = value.toLong();
switch (flash) {
case 0: os << "Not used"; break;
case 8: os << "Fired, commander mode"; break;
case 9: os << "Fired, TTL mode"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon3MakerNote::print0x0088(std::ostream& os,
const Value& value)
{
// Mappings taken from Exiftool
long afpos = value.toLong();
switch (afpos) {
case 0x0000: os << "Center"; break;
case 0x0100: os << "Top"; break;
case 0x0200: os << "Bottom"; break;
case 0x0300: os << "Left"; break;
case 0x0400: os << "Right"; break;
// D70
case 0x00001: os << "Single area, center"; break;
case 0x10002: os << "Single area, top"; break;
case 0x20004: os << "Single area, bottom"; break;
case 0x30008: os << "Single area, left"; break;
case 0x40010: os << "Single area, right"; break;
case 0x1000001: os << "Dynamic area, center"; break;
case 0x1010002: os << "Dynamic area, top"; break;
case 0x1020004: os << "Dynamic area, bottom"; break;
case 0x1030008: os << "Dynamic area, left"; break;
case 0x1040010: os << "Dynamic area, right"; break;
case 0x2000001: os << "Closest subject, center"; break;
case 0x2010002: os << "Closest subject, top"; break;
case 0x2020004: os << "Closest subject, bottom"; break;
case 0x2030008: os << "Closest subject, left"; break;
case 0x2040010: os << "Closest subject, right"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon3MakerNote::print0x0089(std::ostream& os,
const Value& value)
{
// From Exiftool
long b = value.toLong();
switch (b) {
case 0x00: os << "Single"; break;
case 0x01: os << "Continuous"; break;
case 0x02: os << "Delay"; break;
case 0x03: os << "Remote with delay"; break;
case 0x04: os << "Remote"; break;
case 0x16: os << "Exposure bracketing"; break;
case 0x64: os << "White balance bracketing"; break;
default: os << "(" << value << ")"; break;
}
return os;
}
std::ostream& Nikon3MakerNote::print0x008b(std::ostream& os,
const Value& value)
{
// Decoded by Robert Rottmerhusen <*****@*****.**>
if (value.size() != 4) return os << "(" << value << ")";
float a = value.toFloat(0);
long b = value.toLong(1);
long c = value.toLong(2);
if (c == 0) return os << "(" << value << ")";
return os << a * b / c;
}
std::ostream& Nikon3MakerNote::print0x0098(std::ostream& os,
const Value& value)
{
#ifdef EXV_HAVE_LENSDATA
//# List of AF F-Mount lenses - version 1.19
//#-----------------------------------------
//# created by Robert Rottmerhusen 2005
//# for use in non-commercial, GPL or open source software only!
//# please contact me for adding lenses or use in commercial software.
//#
//#"data from TAG 0x98" "ltyp""manuf" "lens name from manuf";
//#
struct {unsigned char lid,stps,focs,focl,aps,apl,lfw, ltype; char *manuf, *lensname;}
fmountlens[] = {
{0x01,0x58,0x50,0x50,0x14,0x14,0x02,0x00, "Nikon", "AF Nikkor 50mm f/1.8"},
{0x02,0x42,0x44,0x5C,0x2A,0x34,0x02,0x00, "Nikon", "AF Zoom-Nikkor 35-70mm f/3.3-4.5"},
{0x02,0x42,0x44,0x5C,0x2A,0x34,0x08,0x00, "Nikon", "AF Zoom-Nikkor 35-70mm f/3.3-4.5"},
{0x04,0x48,0x3C,0x3C,0x24,0x24,0x03,0x00, "Nikon", "AF Nikkor 28mm f/2.8"},
{0x05,0x54,0x50,0x50,0x0C,0x0C,0x04,0x00, "Nikon", "AF Nikkor 50mm f/1.4"},
{0x06,0x54,0x53,0x53,0x24,0x24,0x06,0x00, "Nikon", "AF Micro-Nikkor 55mm f/2.8"},
{0x07,0x40,0x3C,0x62,0x2C,0x34,0x03,0x00, "Nikon", "AF Zoom-Nikkor 28-85mm f/3.5-4.5"},
{0x08,0x40,0x44,0x6A,0x2C,0x34,0x04,0x00, "Nikon", "AF Zoom-Nikkor 35-105mm f/3.5-4.5"},
{0x09,0x48,0x37,0x37,0x24,0x24,0x04,0x00, "Nikon", "AF Nikkor 24mm f/2.8"},
{0x0A,0x48,0x8E,0x8E,0x24,0x24,0x03,0x00, "Nikon", "AF Nikkor 300mm f/2.8 IF-ED"},
{0x0B,0x48,0x7C,0x7C,0x24,0x24,0x05,0x00, "Nikon", "AF Nikkor 180mm f/2.8 IF-ED"},
{0x0D,0x40,0x44,0x72,0x2C,0x34,0x07,0x00, "Nikon", "AF Zoom-Nikkor 35-135mm f/3.5-4.5"},
{0x0E,0x48,0x5C,0x81,0x30,0x30,0x05,0x00, "Nikon", "AF Zoom-Nikkor 70-210mm f/4"},
{0x0F,0x58,0x50,0x50,0x14,0x14,0x05,0x00, "Nikon", "AF Nikkor 50mm f/1.8 N"},
{0x10,0x48,0x8E,0x8E,0x30,0x30,0x08,0x00, "Nikon", "AF Nikkor 300mm f/4 IF-ED"},
{0x11,0x48,0x44,0x5C,0x24,0x24,0x08,0x00, "Nikon", "AF Zoom-Nikkor 35-70mm f/2.8"},
{0x12,0x48,0x5C,0x81,0x30,0x3C,0x09,0x00, "Nikon", "AF Nikkor 70-210mm f/4-5.6"},
{0x13,0x42,0x37,0x50,0x2A,0x34,0x0B,0x00, "Nikon", "AF Zoom-Nikkor 24-50mm f/3.3-4.5"},
{0x14,0x48,0x60,0x80,0x24,0x24,0x0B,0x00, "Nikon", "AF Zoom-Nikkor 80-200mm f/2.8 ED"},
{0x15,0x4C,0x62,0x62,0x14,0x14,0x0C,0x00, "Nikon", "AF Nikkor 85mm f/1.8"},
{0x17,0x3C,0xA0,0xA0,0x30,0x30,0x11,0x00, "Nikon", "Nikkor 500mm f/4 P"},
{0x18,0x40,0x44,0x72,0x2C,0x34,0x0E,0x00, "Nikon", "AF Zoom-Nikkor 35-135mm f/3.5-4.5 N"},
{0x1B,0x44,0x5E,0x8E,0x34,0x3C,0x10,0x00, "Nikon", "AF Zoom-Nikkor 75-300mm f/4.5-5.6"},
{0x1C,0x48,0x30,0x30,0x24,0x24,0x12,0x00, "Nikon", "AF Nikkor 20mm f/2.8"},
{0x1D,0x42,0x44,0x5C,0x2A,0x34,0x12,0x00, "Nikon", "AF Zoom-Nikkor 35-70mm f/3.3-4.5 N"},
{0x1E,0x54,0x56,0x56,0x24,0x24,0x13,0x00, "Nikon", "AF Micro-Nikkor 60mm f/2.8"},
{0x24,0x48,0x60,0x80,0x24,0x24,0x1A,0x02, "Nikon", "AF Zoom-Nikkor ED 80-200mm f/2.8D"},
{0x25,0x48,0x44,0x5c,0x24,0x24,0x1B,0x02, "Nikon", "AF Zoom-Nikkor 35-70mm f/2.8D"},
{0x25,0x48,0x44,0x5c,0x24,0x24,0x52,0x02, "Nikon", "AF Zoom-Nikkor 35-70mm f/2.8D N"},
{0x27,0x48,0x8E,0x8E,0x24,0x24,0xF2,0x02, "Nikon", "AF-I Nikkor 300mm f/2.8D IF-ED"},
{0x2A,0x54,0x3C,0x3C,0x0C,0x0C,0x26,0x02, "Nikon", "AF Nikkor 28mm f/1.4D"},
{0x2C,0x48,0x6A,0x6A,0x18,0x18,0x27,0x02, "Nikon", "AF DC-Nikkor 105mm f/2D"},
{0x2D,0x48,0x80,0x80,0x30,0x30,0x21,0x02, "Nikon", "AF Micro-Nikkor 200mm f/4D IF-ED"},
{0x2E,0x48,0x5C,0x82,0x30,0x3C,0x28,0x02, "Nikon", "AF Nikkor 70-210mm f/4-5.6D"},
{0x31,0x54,0x56,0x56,0x24,0x24,0x25,0x02, "Nikon", "AF Micro-Nikkor 60mm f/2.8D"},
{0x32,0x54,0x6A,0x6A,0x24,0x24,0x35,0x02, "Nikon", "AF Micro-Nikkor 105mm f/2.8D"},
{0x33,0x48,0x2D,0x2D,0x24,0x24,0x31,0x02, "Nikon", "AF Nikkor 18mm f/2.8D"},
{0x36,0x48,0x37,0x37,0x24,0x24,0x34,0x02, "Nikon", "AF Nikkor 24mm f/2.8D"},
{0x37,0x48,0x30,0x30,0x24,0x24,0x36,0x02, "Nikon", "AF Nikkor 20mm f/2.8D"},
{0x38,0x4C,0x62,0x62,0x14,0x14,0x37,0x02, "Nikon", "AF Nikkor 85mm f/1.8D"},
{0x3B,0x48,0x44,0x5C,0x24,0x24,0x3A,0x02, "Nikon", "AF Zoom-Nikkor 35-70mm f/2.8D N"},
{0x3E,0x48,0x3C,0x3C,0x24,0x24,0x3D,0x02, "Nikon", "AF Nikkor 28mm f/2.8D"},
{0x41,0x48,0x7c,0x7c,0x24,0x24,0x43,0x02, "Nikon", "AF Nikkor 180mm f/2.8D IF-ED"},
{0x42,0x54,0x44,0x44,0x18,0x18,0x44,0x02, "Nikon", "AF Nikkor 35mm f/2D"},
{0x43,0x54,0x50,0x50,0x0C,0x0C,0x46,0x02, "Nikon", "AF Nikkor 50mm f/1.4D"},
{0x46,0x3C,0x44,0x60,0x30,0x3C,0x49,0x02, "Nikon", "AF Zoom-Nikkor 35-80mm f/4-5.6D"},
{0x48,0x48,0x8E,0x8E,0x24,0x24,0x4B,0x02, "Nikon", "AF-S Nikkor 300mm f/2.8D IF-ED"},
{0x4A,0x54,0x62,0x62,0x0C,0x0C,0x4D,0x02, "Nikon", "AF Nikkor 85mm f/1.4D IF"},
{0x4C,0x40,0x37,0x6E,0x2C,0x3C,0x4F,0x02, "Nikon", "AF Zoom-Nikkor 24-120mm f/3.5-5.6D IF"},
{0x4D,0x40,0x3C,0x80,0x2C,0x3C,0x62,0x02, "Nikon", "AF Zoom-Nikkor 28-200mm f/3.5-5.6D IF"},
{0x4E,0x48,0x72,0x72,0x18,0x18,0x51,0x02, "Nikon", "AF DC-Nikkor 135mm f/2D"},
{0x4F,0x40,0x37,0x5C,0x2C,0x3C,0x53,0x06, "Nikon", "IX-Nikkor 24-70mm f/3.5-5.6"},
{0x53,0x48,0x60,0x80,0x24,0x24,0x60,0x02, "Nikon", "AF Zoom-Nikkor 80-200mm f/2.8D ED"},
{0x54,0x44,0x5C,0x7C,0x34,0x3C,0x58,0x02, "Nikon", "AF Zoom-Micro Nikkor 70-180mm f/4.5-5.6D ED"},
{0x56,0x48,0x5C,0x8E,0x30,0x3C,0x5A,0x02, "Nikon", "AF Zoom-Nikkor 70-300mm f/4-5.6D ED"},
{0x59,0x48,0x98,0x98,0x24,0x24,0x5D,0x02, "Nikon", "AF-S Nikkor 400mm f/2.8D IF-ED"},
{0x5A,0x3C,0x3E,0x56,0x30,0x3C,0x5E,0x06, "Nikon", "IX-Nikkor 30-60mm f/4-5.6"},
{0x5D,0x48,0x3C,0x5C,0x24,0x24,0x63,0x02, "Nikon", "AF-S Zoom-Nikkor 28-70mm f/2.8D IF-ED"},
{0x5E,0x48,0x60,0x80,0x24,0x24,0x64,0x02, "Nikon", "AF-S Zoom-Nikkor 80-200mm f/2.8D IF-ED"},
{0x5F,0x40,0x3C,0x6A,0x2C,0x34,0x65,0x02, "Nikon", "AF Zoom-Nikkor 28-105mm f/3.5-4.5D IF"},
{0x61,0x44,0x5E,0x86,0x34,0x3C,0x67,0x02, "Nikon", "AF Zoom-Nikkor 75-240mm f/4.5-5.6D"},
{0x63,0x48,0x2B,0x44,0x24,0x24,0x68,0x02, "Nikon", "AF-S Nikkor 17-35mm f/2.8D IF-ED"},
{0x64,0x00,0x62,0x62,0x24,0x24,0x6A,0x02, "Nikon", "PC Micro-Nikkor 85mm f/2.8D"},
{0x65,0x44,0x60,0x98,0x34,0x3C,0x6B,0x0A, "Nikon", "AF VR Zoom-Nikkor 80-400mm f/4.5-5.6D ED"},
{0x66,0x40,0x2D,0x44,0x2C,0x34,0x6C,0x02, "Nikon", "AF Zoom-Nikkor 18-35mm f/3.5-4.5D IF-ED"},
{0x67,0x48,0x37,0x62,0x24,0x30,0x6D,0x02, "Nikon", "AF Zoom-Nikkor 24-85mm f/2.8-4D IF"},
{0x68,0x42,0x3C,0x60,0x2A,0x3C,0x6E,0x06, "Nikon", "AF Zoom-Nikkor 28-80mm f/3.3-5.6G"},
{0x69,0x48,0x5C,0x8E,0x30,0x3C,0x6F,0x06, "Nikon", "AF Zoom-Nikkor 70-300mm f/4-5.6G"},
{0x6A,0x48,0x8E,0x8E,0x30,0x30,0x70,0x02, "Nikon", "AF-S Nikkor 300mm f/4D IF-ED"},
{0x6D,0x48,0x8E,0x8E,0x24,0x24,0x73,0x02, "Nikon", "AF-S Nikkor 300mm f/2.8D IF-ED II"},
{0x6E,0x48,0x98,0x98,0x24,0x24,0x74,0x02, "Nikon", "AF-S Nikkor 400mm f/2.8D IF-ED II"},
{0x6F,0x3C,0xA0,0xA0,0x30,0x30,0x75,0x02, "Nikon", "AF-S Nikkor 500mm f/4D IF-ED"},
{0x70,0x3C,0xA6,0xA6,0x30,0x30,0x76,0x02, "Nikon", "AF-S Nikkor 600mm f/4D IF-ED"},
{0x72,0x48,0x4C,0x4C,0x24,0x24,0x77,0x00, "Nikon", "Nikkor 45mm f/2.8 P"},
{0x74,0x40,0x37,0x62,0x2C,0x34,0x78,0x06, "Nikon", "AF-S Zoom-Nikkor 24-85mm f/3.5-4.5G IF-ED"},
{0x75,0x40,0x3C,0x68,0x2C,0x3C,0x79,0x06, "Nikon", "AF Zoom-Nikkor 28-100mm f/3.5-5.6G"},
{0x76,0x58,0x50,0x50,0x14,0x14,0x7A,0x02, "Nikon", "AF Nikkor 50mm f/1.8D"},
{0x77,0x48,0x5C,0x80,0x24,0x24,0x7B,0x0E, "Nikon", "AF-S VR Zoom-Nikkor 70-200mm f/2.8G IF-ED"},
{0x78,0x40,0x37,0x6E,0x2C,0x3C,0x7C,0x0E, "Nikon", "AF-S VR Zoom-Nikkor 24-120mm f/3.5-5.6G IF-ED"},
{0x79,0x40,0x3C,0x80,0x2C,0x3C,0x7F,0x06, "Nikon", "AF Zoom-Nikkor 28-200mm f/3.5-5.6G IF-ED"},
{0x7A,0x3C,0x1F,0x37,0x30,0x30,0x7E,0x06, "Nikon", "AF-S DX Zoom-Nikkor 12-24mm f/4G IF-ED"},
{0x7B,0x48,0x80,0x98,0x30,0x30,0x80,0x0E, "Nikon", "AF-S VR Zoom-Nikkor 200-400mm f/4G IF-ED"},
{0x7D,0x48,0x2B,0x53,0x24,0x24,0x82,0x06, "Nikon", "AF-S DX Zoom-Nikkor 17-55mm f/2.8G IF-ED"},
{0x7F,0x40,0x2D,0x5C,0x2C,0x34,0x84,0x06, "Nikon", "AF-S DX Zoom-Nikkor 18-70mm f/3.5-4.5G IF-ED"},
{0x80,0x48,0x1A,0x1A,0x24,0x24,0x85,0x06, "Nikon", "AF DX Fisheye-Nikkor 10.5mm f/2.8G ED"},
{0x81,0x54,0x80,0x80,0x18,0x18,0x86,0x0E, "Nikon", "AF-S VR Nikkor 200mm f/2G IF-ED"},
{0x82,0x48,0x8E,0x8E,0x24,0x24,0x87,0x0E, "Nikon", "AF-S VR Nikkor 300mm f/2.8G IF-ED"},
{0x89,0x3C,0x53,0x80,0x30,0x3C,0x8B,0x06, "Nikon", "AF-S DX Zoom-Nikkor 55-200mm f/4-5.6G ED"},
{0x8C,0x40,0x2D,0x53,0x2C,0x3C,0x8E,0x06, "Nikon", "AF-S DX Zoom-Nikkor 18-55mm f/3.5-5.6G ED"},
//#
{0x06,0x3F,0x68,0x68,0x2C,0x2C,0x06,0x00, "Cosina", "100mm F/3.5 Macro"},
//#
{0x26,0x48,0x11,0x11,0x30,0x30,0x1C,0x02, "Sigma", "8mm F4 EX Circular Fisheye"},
{0x48,0x38,0x1F,0x37,0x34,0x3C,0x4B,0x06, "Sigma", "12-24mm F4.5-5.6 EX Aspherical DG HSM"},
{0x02,0x3F,0x24,0x24,0x2C,0x2C,0x02,0x00, "Sigma", "14mm F3.5"},
{0x26,0x48,0x27,0x27,0x24,0x24,0x1C,0x02, "Sigma", "15mm F2.8 EX Diagonal Fish-Eye"},
{0x26,0x40,0x27,0x3F,0x2C,0x34,0x1C,0x02, "Sigma", "15-30mm F3.5-4.5 EX Aspherical DG DF"},
{0x48,0x48,0x2B,0x44,0x24,0x30,0x4B,0x06, "Sigma", "17-35mm F2.8-4 EX DG Aspherical HSM"},
{0x26,0x48,0x2D,0x50,0x24,0x24,0x1C,0x06, "Sigma", "18-50mm F2.8 EX DC"},
{0x26,0x40,0x2D,0x50,0x2C,0x3C,0x1C,0x06, "Sigma", "18-50mm F3.5-5.6 DC"},
{0x26,0x40,0x2D,0x70,0x2B,0x3C,0x1C,0x06, "Sigma", "18-125mm F3.5-5.6 DC"},
{0x26,0x40,0x2D,0x80,0x2C,0x40,0x1C,0x06, "Sigma", "18-200mm F3.5-6.3 DC"},
{0x26,0x58,0x31,0x31,0x14,0x14,0x1C,0x02, "Sigma", "20mm F1.8 EX Aspherical DG DF RF"},
{0x26,0x58,0x37,0x37,0x14,0x14,0x1C,0x02, "Sigma", "24mm F1.8 EX Aspherical DG DF MACRO"},
{0x02,0x46,0x37,0x37,0x25,0x25,0x02,0x00, "Sigma", "24mm F2.8 Macro"},
{0x26,0x54,0x37,0x5C,0x24,0x24,0x1C,0x02, "Sigma", "24-70mm F2.8 EX DG Macro"},
{0x02,0x3F,0x3C,0x5C,0x2D,0x35,0x02,0x00, "Sigma", "28-70mm F3.5-4.5 UC"},
{0x26,0x40,0x3C,0x8E,0x2C,0x40,0x1C,0x02, "Sigma", "28-300mm F3.5-6.3 Macro"},
{0x26,0x40,0x3C,0x80,0x2B,0x3C,0x1C,0x02, "Sigma", "28-200mm F3.5-5.6 Compact Aspherical Hyperzoom Macro"},
{0x26,0x40,0x3C,0x60,0x2C,0x3C,0x1C,0x02, "Sigma", "28-80mm F3.5-5.6 Mini Zoom Macro II Aspherical"},
{0x02,0x40,0x44,0x73,0x2B,0x36,0x02,0x00, "Sigma", "35-135mm F3.5-4.5 a"},
{0x32,0x54,0x50,0x50,0x24,0x24,0x35,0x02, "Sigma", "50mm F2.8 EX DG Macro"},
{0x48,0x3C,0x50,0xA0,0x30,0x40,0x4B,0x02, "Sigma", "50-500mmF4-6.3 EX APO RF HSM"},
{0x26,0x3C,0x54,0x80,0x30,0x3C,0x1C,0x06, "Sigma", "55-200mm F4-5.6 DC"},
{0x48,0x54,0x5C,0x80,0x24,0x24,0x4B,0x02, "Sigma", "70-200mm F2.8 EX APO IF HSM"},
{0x56,0x3C,0x5C,0x8E,0x30,0x3C,0x1C,0x02, "Sigma", "70-300mm F4-5.6 APO Macro Super II"},
{0x02,0x37,0x5E,0x8E,0x35,0x3D,0x02,0x00, "Sigma", "75-300mm F4.5-5.6 APO"},
{0x02,0x48,0x65,0x65,0x24,0x24,0x02,0x00, "Sigma", "90mm F2.8 Macro"},
{0x77,0x44,0x61,0x98,0x34,0x3C,0x7B,0x0E, "Sigma", "80-400mm f4.5-5.6 EX OS"},
{0x48,0x48,0x68,0x8E,0x30,0x30,0x4B,0x02, "Sigma", "100-300mm F4 EX IF HSM"},
{0x26,0x44,0x73,0x98,0x34,0x3C,0x1C,0x02, "Sigma", "135-400mm F4.5-5.6 APO Aspherical"},
{0x48,0x48,0x76,0x76,0x24,0x24,0x4B,0x06, "Sigma", "150mm F2.8 EX DG APO Macro HSM"},
{0x02,0x2F,0x98,0x98,0x3D,0x3D,0x02,0x00, "Sigma", "400mm F5.6 APO"},
//#
{0x03,0x43,0x5C,0x81,0x35,0x35,0x02,0x00, "Soligor", "AF C/D ZOOM UMCS 70-210mm 1:4.5"},
//#
{0x00,0x3C,0x1F,0x37,0x30,0x30,0x00,0x06, "Tokina", "AT-X 124 AF PRO DX - AF 12-24mm f/4"},
{0x00,0x40,0x2B,0x2B,0x2C,0x2C,0x00,0x02, "Tokina", "AT-X 17 AF PRO - AF 17mm f/3.5"},
{0x00,0x54,0x68,0x68,0x24,0x24,0x00,0x02, "Tokina", "AT-X M100 PRO D - 100mm F2.8"},
//#
{0x00,0x36,0x1C,0x2D,0x34,0x3C,0x00,0x06, "Tamron", "SP AF11-18mm F/4.5-5.6 Di II LD Aspherical (IF)"},
{0x07,0x46,0x2B,0x44,0x24,0x30,0x03,0x02, "Tamron", "SP AF17-35mm F/2.8-4 Di LD Aspherical (IF)"},
{0x00,0x3F,0x2D,0x80,0x2B,0x40,0x00,0x06, "Tamron", "AF18-200mm f/3.5-6.3 XR Di II LD Aspherical (IF)"},
{0x00,0x3F,0x2D,0x80,0x2C,0x40,0x00,0x06, "Tamron", "AF18-200mm f/3.5-6.3 XR Di II LD Aspherical (IF) MACRO"},
{0x00,0x48,0x3C,0x6A,0x24,0x24,0x00,0x02, "Tamron", "SP AF28-105mm f/2.8"},
{0x4D,0x41,0x3C,0x8E,0x2B,0x40,0x62,0x02, "Tamron", "AF28-300mm f/3.5-6.3 XR Di LD Aspherical (IF)"},
{0x32,0x53,0x64,0x64,0x24,0x24,0x35,0x02, "Tamron", "SP AF90mm f/2.8 Di 1:1 Macro"},
{0x20,0x3C,0x80,0x98,0x3D,0x3D,0x1E,0x02, "Tamron", "AF200-400mm f/5.6 LD IF"},
{0x00,0x3E,0x80,0xA0,0x38,0x3F,0x00,0x02, "Tamron", "SP AF200-500mm f/5-6.3 Di LD (IF)"},
//#
{0x4D,0x41,0x3C,0x8E,0x2C,0x40,0x62,0x02, "Unknown", "28-300mm F/3.5-6.3 D"},
{0x1E,0x5D,0x64,0x64,0x20,0x20,0x13,0x00, "Unknown", "90mm F/2.5"},
{0x2F,0x40,0x30,0x44,0x2C,0x34,0x29,0x02, "Unknown", "20-35mm F/3.5-4.5D"},
{0x0B,0x3E,0x3D,0x7F,0x2F,0x3D,0x0E,0x00, "Unknown", "29-195mm F/3.8-5.6"},
//#
{0,0,0,0,0,0,0,0, NULL, NULL}
};
if (value.typeId() != undefined) return os << value;
DataBuf lens(value.size());
// ByteOrder is only to satisfy the interface
value.copy(lens.pData_, invalidByteOrder);
int idx = 0;
if (0 == memcmp(lens.pData_, "0100", 4)) {
idx = 6;
}
else if (0 == memcmp(lens.pData_, "0101", 4)) {
idx = 11;
}
else if (0 == memcmp(lens.pData_, "0201", 4)) {
// Here we should decrypt(lens.pData_ + 4, lens.size_ - 4);
// however, the decrypt algorithm requires access to serial number
// and shutter count tags but print functions are static...
idx = 11;
}
if (idx == 0 || lens.size_ < idx + 7) {
// Unknown version or not enough data
return os << value;
}
for (int i = 0; fmountlens[i].lensname != NULL; ++i) {
if ( lens.pData_[idx] == fmountlens[i].lid
&& lens.pData_[idx+1] == fmountlens[i].stps
&& lens.pData_[idx+2] == fmountlens[i].focs
&& lens.pData_[idx+3] == fmountlens[i].focl
&& lens.pData_[idx+4] == fmountlens[i].aps
&& lens.pData_[idx+5] == fmountlens[i].apl
&& lens.pData_[idx+6] == fmountlens[i].lfw) {
// Lens found in database
return os << fmountlens[i].manuf << " " << fmountlens[i].lensname;
}
}
// Lens not found in database
return os << value;
#else
return os << value;
#endif // EXV_HAVE_LENSDATA
}
// *****************************************************************************
// free functions
MakerNote::AutoPtr createNikonMakerNote(bool alloc,
const byte* buf,
long len,
ByteOrder byteOrder,
long offset)
{
// If there is no "Nikon" string it must be Nikon1 format
if (len < 6 || std::string(reinterpret_cast<const char*>(buf), 6)
!= std::string("Nikon\0", 6)) {
return MakerNote::AutoPtr(new Nikon1MakerNote(alloc));
}
// If the "Nikon" string is not followed by a TIFF header, we assume
// Nikon2 format
TiffHeader tiffHeader;
if ( len < 18
|| tiffHeader.read(buf + 10) != 0 || tiffHeader.tag() != 0x002a) {
return MakerNote::AutoPtr(new Nikon2MakerNote(alloc));
}
// Else we have a Nikon3 makernote
return MakerNote::AutoPtr(new Nikon3MakerNote(alloc));
}
} // namespace Exiv2
namespace Internal {
// Sigma (Foveon) MakerNote Tag Info
const TagInfo SigmaMakerNote::tagInfo_[] = {
TagInfo(0x0002, "SerialNumber", N_("Serial Number"),
N_("Camera serial number"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0003, "DriveMode", N_("Drive Mode"),
N_("Drive mode"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0004, "ResolutionMode", N_("Resolution Mode"),
N_("Resolution mode"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0005, "AutofocusMode", N_("Autofocus Mode"),
N_("Autofocus mode"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0006, "FocusSetting", N_("Focus Setting"),
N_("Focus setting"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0007, "WhiteBalance", N_("White Balance"),
N_("White balance"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0008, "ExposureMode", N_("Exposure Mode"),
N_("Exposure mode"),
sigmaId, makerTags, asciiString, -1, print0x0008),
TagInfo(0x0009, "MeteringMode", N_("Metering Mode"),
N_("Metering mode"),
sigmaId, makerTags, asciiString, -1, print0x0009),
TagInfo(0x000a, "LensRange", N_("Lens Range"),
N_("Lens focal length range"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x000b, "ColorSpace", N_("Color Space"),
N_("Color space"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x000c, "Exposure", N_("Exposure"),
N_("Exposure"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x000d, "Contrast", N_("Contrast"),
N_("Contrast"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x000e, "Shadow", N_("Shadow"),
N_("Shadow"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x000f, "Highlight", N_("Highlight"),
N_("Highlight"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0010, "Saturation", N_("Saturation"),
N_("Saturation"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0011, "Sharpness", N_("Sharpness"),
N_("Sharpness"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0012, "FillLight", N_("Fill Light"),
N_("X3 Fill light"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0014, "ColorAdjustment", N_("Color Adjustment"),
N_("Color adjustment"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0015, "AdjustmentMode", N_("Adjustment Mode"),
N_("Adjustment mode"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0016, "Quality", N_("Quality"),
N_("Quality"),
sigmaId, makerTags, asciiString, -1, printStripLabel),
TagInfo(0x0017, "Firmware", N_("Firmware"),
N_("Firmware"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0018, "Software", N_("Software"),
N_("Software"),
sigmaId, makerTags, asciiString, -1, printValue),
TagInfo(0x0019, "AutoBracket", N_("Auto Bracket"),
N_("Auto bracket"),
sigmaId, makerTags, asciiString, -1, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownSigmaMakerNoteTag)", "(UnknownSigmaMakerNoteTag)",
N_("Unknown SigmaMakerNote tag"),
sigmaId, makerTags, asciiString, -1, printValue)
};
const TagInfo* SigmaMakerNote::tagList()
{
return tagInfo_;
}
std::ostream& SigmaMakerNote::printStripLabel(std::ostream& os,
const Value& value,
const ExifData*)
{
std::string v = value.toString();
std::string::size_type pos = v.find(':');
if (pos != std::string::npos) {
if (v[pos + 1] == ' ') ++pos;
v = v.substr(pos + 1);
}
return os << v;
}
std::ostream& SigmaMakerNote::print0x0008(std::ostream& os,
const Value& value,
const ExifData*)
{
switch (value.toString()[0]) {
case 'P':
os << _("Program");
break;
case 'A':
os << _("Aperture priority");
break;
case 'S':
os << _("Shutter priority");
break;
case 'M':
os << _("Manual");
break;
default:
os << "(" << value << ")";
break;
}
return os;
}
std::ostream& SigmaMakerNote::print0x0009(std::ostream& os,
const Value& value,
const ExifData*)
{
switch (value.toString()[0]) {
case 'A':
os << _("Average");
break;
case 'C':
os << _("Center");
break;
case '8':
os << _("8-Segment");
break;
default:
os << "(" << value << ")";
break;
}
return os;
}
}
namespace Exiv2 {
//! @cond IGNORE
PanasonicMakerNote::RegisterMn::RegisterMn()
{
MakerNoteFactory::registerMakerNote("Panasonic", "*", createPanasonicMakerNote);
MakerNoteFactory::registerMakerNote(
panasonicIfdId, MakerNote::AutoPtr(new PanasonicMakerNote));
ExifTags::registerMakerTagInfo(panasonicIfdId, tagInfo_);
}
//! @endcond
//! Quality, tag 0x0001
extern const TagDetails panasonicQuality[] = {
{ 2, N_("High") },
{ 3, N_("Normal") },
{ 6, N_("Very High") },
{ 7, N_("Raw") }
};
//! WhiteBalance, tag 0x0003
extern const TagDetails panasonicWhiteBalance[] = {
{ 1, N_("Auto") },
{ 2, N_("Daylight") },
{ 3, N_("Cloudy") },
{ 4, N_("Halogen") },
{ 5, N_("Manual") },
{ 8, N_("Flash") },
{ 10, N_("Black and white") }
};
//! FocusMode, tag 0x0007
extern const TagDetails panasonicFocusMode[] = {
{ 1, N_("Auto") },
{ 2, N_("Manual") },
{ 4, N_("Auto, focus button") },
{ 5, N_("Auto, continuous") }
};
//! ImageStabilizer, tag 0x001a
extern const TagDetails panasonicImageStabilizer[] = {
{ 2, N_("On, Mode 1") },
{ 3, N_("Off") },
{ 4, N_("On, Mode 2") }
};
//! Macro, tag 0x001c
extern const TagDetails panasonicMacro[] = {
{ 1, N_("On") },
{ 2, N_("Off") },
{ 257, N_("Tele-macro") }
};
//! ShootingMode, tag 0x001f
extern const TagDetails panasonicShootingMode[] = {
{ 1, N_("Normal") },
{ 2, N_("Portrait") },
{ 3, N_("Scenery") },
{ 4, N_("Sports") },
{ 5, N_("Night portrait") },
{ 6, N_("Program") },
{ 7, N_("Aperture priority") },
{ 8, N_("Shutter-speed priority") },
{ 9, N_("Macro") },
{ 11, N_("Manual") },
{ 13, N_("Panning") },
{ 18, N_("Fireworks") },
{ 19, N_("Party") },
{ 20, N_("Snow") },
{ 21, N_("Night scenery") },
{ 22, N_("Food") }
};
//! Audio, tag 0x0020
extern const TagDetails panasonicAudio[] = {
{ 1, N_("Yes") },
{ 2, N_("No") }
};
//! ColorEffect, tag 0x0028
extern const TagDetails panasonicColorEffect[] = {
{ 1, N_("Off") },
{ 2, N_("Warm") },
{ 3, N_("Cool") },
{ 4, N_("Black and white") },
{ 5, N_("Sepia") }
};
//! BustMode, tag 0x002a
extern const TagDetails panasonicBurstMode[] = {
{ 0, N_("Off") },
{ 1, N_("Low/High quality") },
{ 2, N_("Infinite") }
};
//! Contrast, tag 0x002c
extern const TagDetails panasonicContrast[] = {
{ 0, N_("Normal") },
{ 1, N_("Low") },
{ 2, N_("High") },
{ 256, N_("Low") },
{ 272, N_("Standard") },
{ 288, N_("High") }
};
//! NoiseReduction, tag 0x002d
extern const TagDetails panasonicNoiseReduction[] = {
{ 0, N_("Standard") },
{ 1, N_("Low") },
{ 2, N_("High") }
};
//! SelfTimer, tag 0x002e
extern const TagDetails panasonicSelfTimer[] = {
{ 1, N_("Off") },
{ 2, N_("10s") },
{ 3, N_("2s") }
};
//! Rotation, tag 0x0030
extern const TagDetails panasonicRotation[] = {
{ 1, N_("Horizontal (normal)") },
{ 6, N_("Rotate 90 CW") },
{ 8, N_("Rotate 270 CW") }
};
//! ColorMode, tag 0x0032
extern const TagDetails panasonicColorMode[] = {
{ 0, N_("Normal") },
{ 1, N_("Natural") }
};
// Panasonic MakerNote Tag Info
const TagInfo PanasonicMakerNote::tagInfo_[] = {
TagInfo(0x0001, "Quality", N_("Quality"),
N_("Image Quality"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicQuality)),
TagInfo(0x0002, "FirmwareVersion", N_("Firmware Version"),
N_("Firmware version"),
panasonicIfdId, makerTags, undefined, printValue),
TagInfo(0x0003, "WhiteBalance", N_("White Balance"),
N_("White balance setting"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicWhiteBalance)),
TagInfo(0x0004, "0x0004", "0x0004",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0007, "FocusMode", N_("Focus Mode"),
N_("Focus mode"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicFocusMode)),
TagInfo(0x000f, "SpotMode", N_("Spot Mode"), N_("Spot mode"),
panasonicIfdId, makerTags, unsignedByte, print0x000f),
TagInfo(0x001a, "ImageStabilizer", N_("ImageStabilizer"),
N_("Image stabilizer"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicImageStabilizer)),
TagInfo(0x001c, "Macro", N_("Macro"),
N_("Macro mode"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicMacro)),
TagInfo(0x001f, "ShootingMode", N_("Shooting Mode"),
N_("Shooting mode"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicShootingMode)),
TagInfo(0x0020, "Audio", N_("Audio"),
N_("Audio"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicAudio)),
TagInfo(0x0021, "DataDump", N_("Data Dump"),
N_("Data dump"),
panasonicIfdId, makerTags, undefined, printValue),
TagInfo(0x0022, "0x0022", "0x0022",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0023, "WhiteBalanceBias", N_("White Balance Bias"),
N_("White balance adjustment"),
panasonicIfdId, makerTags, unsignedShort, print0x0023),
TagInfo(0x0024, "FlashBias", N_("FlashBias"),
N_("Flash bias"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0025, "SerialNumber", N_("Serial Number"),
N_("This number is unique, and contains the date of manufacture, "
"but is not the same as the number printed on the camera body."),
panasonicIfdId, makerTags, undefined, printValue),
TagInfo(0x0026, "0x0026", "0x0026",
N_("Unknown"),
panasonicIfdId, makerTags, undefined, printValue),
TagInfo(0x0027, "0x0027", "0x0027",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0028, "ColorEffect", N_("Color Effect"),
N_("Color effect"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicColorEffect)),
TagInfo(0x0029, "0x0029", "0x0029",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x002a, "BurstMode", N_("Burst Mode"),
N_("Burst mode"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicBurstMode)),
TagInfo(0x002b, "SequenceNumber", N_("Sequence Number"),
N_("Sequence number"),
panasonicIfdId, makerTags, unsignedLong, printValue),
TagInfo(0x002c, "Contrast", N_("Contrast"),
N_("Contrast setting"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicContrast)),
TagInfo(0x002d, "NoiseReduction", N_("NoiseReduction"),
N_("Noise reduction"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicNoiseReduction)),
TagInfo(0x002e, "SelfTimer", N_("Self Timer"),
N_("Self timer"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicSelfTimer)),
TagInfo(0x002f, "0x002f", "0x002f",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0030, "Rotation", N_("Rotation"),
N_("Rotation"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicRotation)),
TagInfo(0x0031, "0x0031", "0x0031",
N_("Unknown"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0032, "ColorMode", N_("Color Mode"),
N_("Color mode"),
panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicColorMode)),
TagInfo(0x0036, "TravelDay", N_("Travel Day"),
N_("Travel day"),
panasonicIfdId, makerTags, unsignedShort, printValue),
TagInfo(0x0e00, "PrintIM", N_("Print IM"),
N_("PrintIM information"),
minoltaIfdId, makerTags, undefined, printValue),
TagInfo(0x4449, "0x4449", "0x4449",
N_("Unknown"),
panasonicIfdId, makerTags, undefined, printValue),
// End of list marker
TagInfo(0xffff, "(UnknownPanasonicMakerNoteTag)", "(UnknownPanasonicMakerNoteTag)",
N_("Unknown PanasonicMakerNote tag"),
panasonicIfdId, makerTags, invalidTypeId, printValue)
};
const TagInfo* PanasonicMakerNote::tagList()
{
return tagInfo_;
}
PanasonicMakerNote::PanasonicMakerNote(bool alloc)
: IfdMakerNote(panasonicIfdId, alloc, false)
{
byte buf[] = {
'P', 'a', 'n', 'a', 's', 'o', 'n', 'i', 'c', 0x00, 0x00, 0x00
};
readHeader(buf, 12, byteOrder_);
}
PanasonicMakerNote::PanasonicMakerNote(const PanasonicMakerNote& rhs)
: IfdMakerNote(rhs)
{
}
int PanasonicMakerNote::readHeader(const byte* buf,
long len,
ByteOrder /*byteOrder*/)
{
if (len < 12) return 1;
header_.alloc(12);
memcpy(header_.pData_, buf, header_.size_);
// Adjust the offset of the IFD for the prefix
start_ = 12;
return 0;
}
int PanasonicMakerNote::checkHeader() const
{
int rc = 0;
// Check the Panasonic prefix
if ( header_.size_ < 12
|| std::string(reinterpret_cast<char*>(header_.pData_), 9)
!= std::string("Panasonic", 9)) {
rc = 2;
}
return rc;
}
PanasonicMakerNote::AutoPtr PanasonicMakerNote::create(bool alloc) const
{
return AutoPtr(create_(alloc));
}
PanasonicMakerNote* PanasonicMakerNote::create_(bool alloc) const
{
AutoPtr makerNote(new PanasonicMakerNote(alloc));
assert(makerNote.get() != 0);
makerNote->readHeader(header_.pData_, header_.size_, byteOrder_);
return makerNote.release();
}
PanasonicMakerNote::AutoPtr PanasonicMakerNote::clone() const
{
return AutoPtr(clone_());
}
PanasonicMakerNote* PanasonicMakerNote::clone_() const
{
return new PanasonicMakerNote(*this);
}
std::ostream& PanasonicMakerNote::print0x000f(std::ostream& os,
const Value& value)
{
if (value.count() < 2 || value.typeId() != unsignedByte) {
return os << value;
}
long l0 = value.toLong(0);
if (l0 == 1) os << _("On");
else if (l0 == 16) os << _("Off");
else os << value;
return os;
} // PanasonicMakerNote::print0x000f
std::ostream& PanasonicMakerNote::print0x0023(std::ostream& os,
const Value& value)
{
std::ostringstream oss;
oss.copyfmt(os);
os << std::fixed << std::setprecision(1)
<< value.toLong() / 3 << _(" EV");
os.copyfmt(oss);
return os;
} // PanasonicMakerNote::print0x0023
// *****************************************************************************
// free functions
MakerNote::AutoPtr createPanasonicMakerNote(bool alloc,
const byte* /*buf*/,
long /*len*/,
ByteOrder /*byteOrder*/,
long /*offset*/)
{
return MakerNote::AutoPtr(new PanasonicMakerNote(alloc));
}
} // namespace Exiv2
